化悲痛为力量——暑假刷题走起

6.21

【思维】接雨水-力扣

题目描述不贴了，在上面的链接里↑

　　第一遍写的思路过于简单，按每层遍历，还可以递归少写点代码。但时间复杂度O(n*n)，导致在复杂数据点超时。
　　参考了windliang的题解才想到可以按列遍历，每个柱子能储存的雨水只和左边所有柱子的最高lmax，与右边所有最高rmax有关。两者中的较小者min减去该柱子的高度h得到的结果和0相比的较大值就是答案。如果这个差小于等于0，就应该等于0。
　　进一步还可以用单调栈储存数据，使空间复杂度再次降低。（这里下次好好研究一下）

参考代码：

class Solution {
public:
    int trap(vector<int>& height) {
        int rmax=0,lmax=0,len=height.size(),sum=0;
        int Max1[100000],Max2[100000];
        for(int i=0;i<len;++i){
            if(i>0) rmax=max(rmax,height.at(i-1));
            Max1[i]=rmax;
        }
        for(int i=len-1;i>=0;--i){
            if(i+1<len) lmax=max(lmax,height.at(i+1));
            Max2[i]=lmax;
        }
        for(int i=0;i<len;++i){
            int tmp=min(Max1[i],Max2[i]);
            sum+=max(tmp-height.at(i),0);
        }
       return sum;
    }
};

6.22

【思维】模式匹配-力扣

题目描述在上面的链接里↑　　

　　一开始想了三个思路。①枚举，搜索匹配串中重复出现的子串。如果有重复的子串可能性多，则效率太低，pass；②从匹配串入手，看能匹配什么模式，再查模式串是否是其中一种情况。实际上与①本质相同，pass；③意识到匹配题最好从模式串入手，结合基本计算，匹配串的可能组合就是有限的，可行。

　　核心：解不定方程。anum*alen + bnum*blen=vlen => anum和bnum可以从模式串p中数出、作系数，alen和blen相当于未知数

　　特殊情况：重复子串a_re和b_re不能相等，但可以有一个为空串；对于anum和bnum有一个为0、都为0的情况要提前讨论。

参考代码：

class Solution {
public:
    bool patternMatching(string pattern, string value) {
        string p=pattern, v=value;
        int plen=p.length(), vlen=v.length(), tmp=0, anum=0, bnum=0;
        for(int i=0;i<plen;++i){
            if(p[i]=='a') anum++;
            else bnum++;
        }
//根据a和b的数量以及目标串的长度，解二元一次方程    
        if(anum+bnum==0){
            if(v.length()!=0) return false;
            return true;
        }
        if(anum==0||bnum==0){
            int num=anum+bnum;
            if( vlen%num !=0) return false;
            string tmp,re;
            re.assign(v, 0, vlen/num);
            for(int i=0;i<vlen;i+=vlen/num){
                tmp.assign(v, i, vlen/num);
                if(tmp!=re) return false;
            }
            return true;
        }
        for(int i=0; i<=(vlen/anum); ++i){
            if( (vlen-i*anum)%bnum==0 ){
                int alen=i, blen=(vlen-i*anum)/bnum;
                string tmp, re_a, re_b;
                int ptr=0;//比对指针 
                bool a_occur=false, b_occur=false, find=true;
                for(int j=0;j<plen;++j){
                    if(a_occur && b_occur && re_a==re_b) break;
                    if(p[j]=='a'){
                        tmp.assign(v,ptr,alen);
                        ptr+=alen;
                        if(!a_occur){
                            re_a=tmp;
                            a_occur=1;
                        }
                        else{
                            if(tmp!=re_a){
                                find=false;
                                break;
                            }
                        }
                    }
                    else{
                        tmp.assign(v,ptr,blen);
                        ptr+=blen;
                        if(!b_occur){
                            re_b=tmp;
                            b_occur=1;
                        }
                        else{
                            if(tmp!=re_b){
                                find=false;
                                break;
                            }
                        }
                    }
                }
                if(re_a!=re_b && find) return true;
            }
        }
        return false;
    }
};

 6.23

【手感-进制计算】二进制求和-力扣

今天忙着投实习，刷题太水了（这个借口真烂x）

  这道是简单题，一遍读懂题意很重要。

参考代码：

class Solution {
public:
    string addBinary(string a, string b) {
        string ans="";
        int alen=a.length(), blen=b.length();
        int p1=alen-1, p2=blen-1, res=0;
        while(p1>=0 || p2>=0){
            if(p1>=0) res+=a[p1]-'0';
            if(p2>=0) res+=b[p2]-'0';
            string tmp="x";
            tmp[0]=res%2+'0';
            ans=tmp+ans;
            res/=2;
            p1--;
            p2--;
        }
        while(res>0){
            string tmp="x";
            tmp[0]=res%2+'0';
            ans=tmp+ans;
            res/=2;           
        }
        int cnt=0;
        if(ans[0]=='0'){
            for(int i=0; i<ans.length(); ++i){
                if(i==ans.length()-1){
                    string tmp="0";
                    tmp[0]=ans[ans.length()-1];
                    return tmp;
                }
                if(ans[i]!='0') break;
                else cnt++;
            }
        }
        ans.assign(ans, cnt, ans.length()-cnt);
        return ans;
    }
};

 6.24

【双指针】最接近的三数之和-力扣

　　因为是三数之和、且不是求相等而是相近，用二重循环+二分排序查找似乎比双指针慢很多，但两者都要注意边界情况( |pb-pc| ==1时以及到达此状态前一刻的情况)，可以多建几个临时变量储存结果。

参考代码：

//①排序+二分查找法
class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int a, b, c, vlen=nums.size();
        int minloc[3]={0};
        for(int i=vlen-1;i>=0;--i){
            for(int j=i-1;j>=0;--j){
                a=nums.at(i);
                b=nums.at(j);
                c=target-a-b;
                int r=0, l=j-1;
                if(l<0) break;
                while(l-r>1){
                    if( abs( nums.at(r)-c ) > abs( nums.at(l)-c )){
                        r=(r+l)/2;
                    }
                    else{
                        l=(r+l)/2;
                    }
                }
                if( abs( nums.at(r)-c ) > abs( nums.at(l)-c )) r=l;
                if((i==vlen-1 && j==vlen-2) || abs(nums.at(minloc[0])+nums.at(minloc[1])+nums.at(minloc[2])-target)>abs(nums.at(i)+nums.at(j)+nums.at(r)-target)){
                    minloc[2]=r;
                    minloc[0]=i;
                    minloc[1]=j;
                }
            }
        }
        return nums.at(minloc[0])+nums.at(minloc[1])+nums.at(minloc[2]);
    }
};

//②排序+双指针法
class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        sort(nums.begin(),nums.end());
        int vlen=nums.size(), pb, pc, sum, ans=1<<30;
        for(int i=vlen-1;i>=0;--i){
            pb=i-1;pc=0;
            if(pb<=0) break;
            while(pb-pc>1){
                sum=nums.at(i)+nums.at(pb)+nums.at(pc);
                if( sum==target ) return target;
                if( sum>target ) pb--;
                else pc++;
            }
            int sum2=nums.at(i)+nums.at(pb)+nums.at(pc);
            if( i>2 && abs(sum2-target)<abs(sum-target) ) sum=sum2;
            else if(i<=2) sum=sum2;
            if( abs(sum-target)<abs(ans-target) ) ans=sum;
        }
        return ans;
    }
};

 6.25

【动规】单词拆分-力扣

　　这道题有点意思，题意很简单，在字典中查找、匹配，问是否能用字典词组成目标串。一开始的思路是对字典排序+二分查找起始点(首字母与当前待匹配字符串首字母相同的字典词)+递归，但超时了。然后动规，建一个set，只储存匹配不到的子字符串(能匹配到的一定是答案，肯定已经return true了)，每次递归前先查是否该字符串在set里，是则直接return false。

　　另外，有个局部优化是要先贪心匹配最长的字典单词。试了一下，将二分查找到的位置记为r。
　　①未优化的写法是从r开始向两边±i(i=0,1,2,3……)地搜索，往下递归，两边都越界或都不再匹配则退出循环；
　　②优化后，从r开始往后找(sort函数默认按字典序排序，头部相同，尾部更长的单词在后面)，找到最后一个首字母能匹配上的位置maxloc，然后再从maxloc往前遍历，每一层向下递归。

　　参考代码中写了个小函数bool HeadOf(string A， string B)来判断是否A是B的头部。

参考代码：

//①动规-未优化方法
class Solution {
public:
    set<string> fail;
    bool HeadOf(string A, string B){
        if(A.length()>B.length()) return false;
        for(int i=0;i<A.length();++i){
            if(A[i]!=B[i]) return false;
        }
        return true;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
        auto p=fail.find(s);
        if(p!=fail.end()) return false;
        if(s=="") return true;
        sort(wordDict.begin(), wordDict.end());
        int wlen=wordDict.size(), slen=s.length();
        if(wlen==0){
            fail.insert(s);
            return false;
        }
        int r=0, l=wlen-1, maxloc=-1;
        while(l-r>1){
            if( wordDict.at( (r+l)/2 )[0] < s[0]) r=(r+l)/2;
            else l=(r+l)/2;
        }
        if( wordDict.at(r)[0]==s[0] || wordDict.at(l)[0]==s[0]){
            for(int i=0;;i++){
                if(r+i>=wlen && r-i<0) break;
                if(r+i<wlen && wordDict.at(r+i)[0]==s[0] && HeadOf(wordDict.at(r+i),s) ){
                    string tmp;
                    tmp.assign(s,wordDict.at(r+i).length(),slen-wordDict.at(r+i).length());
                    if(wordBreak(tmp,wordDict)) return true;
                }
                if(i!=0 && r-i>=0 && wordDict.at(r-i)[0]==s[0] && HeadOf(wordDict.at(r-i),s)){
                    string tmp;
                    tmp.assign(s,wordDict.at(r-i).length(),slen-wordDict.at(r-i).length());
                    if(wordBreak(tmp,wordDict)) return true;
                }
            }
        }
        fail.insert(s);
        return false;
    }
};

//②动规-优化方法
class Solution {
public:
    set<string> fail;
    bool HeadOf(string A, string B){
        if(A.length()>B.length()) return false;
        for(int i=0;i<A.length();++i){
            if(A[i]!=B[i]) return false;
        }
        return true;
    }
    bool wordBreak(string s, vector<string>& wordDict) {
        auto p=fail.find(s);
        if(p!=fail.end()) return false;
        if(s=="") return true;
        sort(wordDict.begin(), wordDict.end());
        int wlen=wordDict.size(), slen=s.length();
        if(wlen==0){
            fail.insert(s);
            return false;
        }
        int r=0, l=wlen-1, maxloc=-1;
        while(l-r>1){
            if( wordDict.at( (r+l)/2 )[0] < s[0]) r=(r+l)/2;
            else l=(r+l)/2;
        }
        for(int i=r;i<wlen;++i){
            if(wordDict.at(i)[0]==s[0]) maxloc=i;
        }
        if(maxloc==-1){
            fail.insert(s);
            return false;
        }
        for(int i=maxloc;i>=r;i--){
            if(wordDict.at(i)[0]==s[0] && HeadOf(wordDict.at(i),s) ){
                string tmp;
                tmp.assign(s,wordDict.at(i).length(),slen-wordDict.at(i).length());
                if(wordBreak(tmp,wordDict)) return true;
            }
        }
        fail.insert(s);
        return false;
    }
};

！且慢——刚刚参考了dalao的代码，发现动规也被我做复杂了orz。可以从另一面考虑，用dp[i]==true/false记录原始待匹配单词的前i个字符是否恰好能被字典词匹配上，这样不用递归都行。另外，dalao还对其代码做了进一步优化，即找到字典中单词的最大长度maxWordLength，在循环计算时，对前i个单词的分割就可以从i-maxWordLength开始，如果这个数<0，就从0开始。

神奇版代码：

bool wordBreak(string s, vector<string>& wordDict) {
    vector<bool> dp(s.size()+1, false);
    unordered_set<string> m(wordDict.begin(), wordDict.end());
    dp[0] = true;
    //获取最长字符串长度
    int maxWordLength = 0;
    for (int i = 0; i < wordDict.size(); ++i){
        maxWordLength = std::max(maxWordLength, (int)wordDict[i].size());
    }
    for (int i = 1; i <= s.size(); ++i){
        for (int j = std::max(i-maxWordLength, 0); j < i; ++j){
            if (dp[j] && m.find(s.substr(j, i-j)) != m.end()){
                dp[i] = true;
                break;
            }
        }
    }
    return dp[s.size()];
}

 后记：以上三种方法的速度差异还是蛮大的，分别是48ms--16ms--0ms，orz……

6.26

【手感-链表操作】移除重复节点-力扣

　　两种思路，①使用额外内存，用set储存到目前为止出现过的元素，一次遍历，删除出现过的节点；②不使用额外内存，两个指针逐个遍历每个未删除的节点。简单题，只写了第二种方法。

参考代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeDuplicateNodes(ListNode* head) {
        ListNode* p1=head;
        ListNode* p2=head;
        if(p1==NULL) return head;
        while((*p1).next!=NULL){
            if(p2==NULL || (*p2).next==NULL){
                p1=(*p1).next;
                p2=p1;
            }
            else if( (*(*p2).next).val==(*p1).val ){
                (*p2).next= (*(*p2).next).next;
            }
            else{
                p2=(*p2).next;
            }
        }
        return head;
    }
};

 6.27

【手感-链表操作】反转链表-力扣

　　题不难，可以学习三种翻转方法。①三个指针交替翻转，其中一个是临时存储用的；②递归，如果当前节点或其下一个节点等于NULL，就直接返回当前节点。否则，新建一个res节点，保存下一层递归的返回值，下一层递归的参数的是当前头节点的下一个节点。在每一层中让当前节点的next节点的next指向自己，之后当前节点的next节点指向NULL，返回res节点；③神奇版双指针法。从头节点开始，向后遍历。把每个节点的next指向节点保存在头节点指针中，然后该节点的next指向前一个节点。这其中用两个指针保存即可（头节点充当了①方法中的第三个临时节点）。

参考代码（注：②③的思路和代码都是借鉴huwt的）：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */

//法①
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL) return NULL;
        if(head->next==NULL) return head;
        ListNode* pre=NULL;
        ListNode* cur=head;
        ListNode* tmp=cur->next;
        while(cur!=NULL){
            tmp=cur->next;
            cur->next=pre;
            pre=cur;
            cur=tmp;
        }
        return pre;
    }
};

//法②
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = NULL;
        return ret;
    }
};

//法③
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL) { return NULL; }
        ListNode* cur = head;
        while (head->next != NULL) {
            ListNode* t = head->next->next;
            head->next->next = cur;
            cur = head->next;
            head->next = t;
        }
        return cur;
    }
};

 6.28

【思维】判断路径是否相交-力扣

　　很有意思的题，难在思路，实现很简单，过目不忘。

参考代码：

//大佬解答，妙！
class Solution {
public:
    bool isPathCrossing(string path) {
        set<pair<int, int> > st;
        st.insert(make_pair(0, 0));
        int x = 0, y = 0;
        for(char c : path) {
            if(c == 'N') {
                x++;
            }
            else if(c == 'S') x--;
            else if(c == 'E') y++;
            else y--;
            auto tmp = make_pair(x, y);
            if(st.count(tmp)) return true;//每点状态唯一，储存状态到set，只需判断是否遇到过该状态
            st.insert(tmp);
        }
        return false;
    }
};

【双指针】长度最小的子数组-力扣

　　三种做法（为何没有一下看破！面壁去）。①极端的暴力循环法/前缀和暴力循环法；②前缀和+二分查找法；③双指针法。

　　看到求“xx最小的子问题”的题就以为是动规，结果自己跳坑了。

参考代码：

//①自己用了前缀和暴力循环法过的
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n=nums.size();
        vector<int> ori=nums;
        int sum[33200]={0};
        for(int i=0;i<n;++i){
            if(i>0) sum[i]=sum[i-1]+nums[i];
            else sum[0]=nums[0];
        }
        sort(nums.begin(),nums.end());
        int tmp=0, mmin=0, mmax=0;
        for(int i=0;i<n;++i){
            tmp+=nums[i];
            if(tmp>=s){
                mmax=i+1;
                break;
            }
        }
        tmp=0;
        for(int i=n-1;i>=0;--i){
            tmp+=nums[i];
            if(tmp>=s){
                mmin=n-i;
                break;
            }
        }
        if(mmin==mmax) return mmin;
        for(int k=mmin;k<=mmax;++k){
            for(int i=0;i<n;++i){
                if(i+k-1>=n) break;
                if(sum[i+k-1]-sum[i]+ori[i]>=s) return k;
            }
        }
        return 0;
    }
};

//②前缀和+二分查找法
class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        vector<int> sums(n + 1, 0); //可以动态指定vector长度
        for (int i = 1; i <= n; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }
        for (int i = 1; i <= n; i++) {
            int target = s + sums[i - 1];
            auto bound = lower_bound(sums.begin(), sums.end(), target);//啊别忘二分查找
            if (bound != sums.end()) {
                ans = min(ans, static_cast<int>((bound - sums.begin()) - (i - 1)));
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

//③双指针法
class Solution {//双指针法。一开始想到要用动规储存，但实际上不用储存，用双指针即可。
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        int start = 0, end = 0;
        int sum = 0;
        while (end < n) {
            sum += nums[end];
            while (sum >= s) {//满足条件就更新答案
                ans = min(ans, end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;//每次迭代end往右移
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

 6.29

【思维-哈希表】罗马数字转整数-力扣

　　有、意思的题，不要想复杂了。

参考代码：

class Solution {
public:
    int romanToInt(string s) {
        int len=s.length(), ans=0;
        int v[22]={0};//类似于哈希的存储方式
        v[(int)'I'-67]=1;
        v[(int)'V'-67]=5;
        v[(int)'X'-67]=10;
        v[(int)'L'-67]=50;
        v[(int)'C'-67]=100;
        v[(int)'D'-67]=500;
        v[(int)'M'-67]=1000;
        for(int i=0;i<len;++i){
            if(i==len-1) ans+=v[(int)s[i]-67];
            else{
                int a=v[(int)s[i]-67];
                int b=v[(int)s[i+1]-67];
                if(a<b){
                    ans+=b-a;
                    i++;
                }
                else ans+=a;
            }
        }
        return ans;
    }
};

　　此题的姊妹篇是 整数转罗马数字-力扣

虽然这两道题在LeetCode上分别被标为简单、中等难度，我私以为后一道题更容易通过找规律，只需求解一个“类”进制转换问题。

参考代码：

class Solution {
public:
    string digit(int x, string one, string five, string ten){
        string d="";
        if(x<4){
            for(int i=0;i<x;++i){
                d+=one;
            }
            return d;
        }
        else if(x==4) return one+five;
        else if(x==9) return one+ten;
        else{
            d=five;
            for(int i=0;i<x-5;++i){
                d+=one;
            }
            return d;
        }
        return "error";
    }
    string intToRoman(int num) {
        string d1, d2, d3, d4;
        d1=digit(num%10,"I","V","X");
        num/=10;
        d2=digit(num%10,"X","L","C");
        num/=10;
        d3=digit(num%10,"C","D","M");
        num/=10;
        d4=digit(num%10,"M","Error1","Error2");
        return d4+d3+d2+d1;
    }
};

 6.30

【复习-STL】用两个栈实现队列-力扣

　　程设作业似乎做过一道类似的，复习一下也好。

参考代码：

class CQueue {
public:
    stack<int> pos;
    stack<int> rev;
    CQueue() {//栈的函数有push top pop
    }
    void appendTail(int value) {
        rev.push(value);
    }
    int deleteHead() {
        if(!pos.empty()){
            int tmp=pos.top();
            pos.pop();
            return tmp;
        }
        while(!rev.empty()){
            int tmp=rev.top();
            pos.push(tmp);
            rev.pop();
        }
        if(!pos.empty()){
            int tmp=pos.top();
            pos.pop();
            return tmp;
        }
        return -1;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

 7.1

【复习-动规】最长重复子数组-力扣

　　这题与“最长公共子序列”有点相似，但暗含有连续数组的意思，某种程度上简化了状态转移方程。节省内存可以用一维数组，对数组剩下的那一维度逆序遍历，省略的维度顺序遍历即可。

参考代码：

class Solution {
public:
    int findLength(vector<int>& A, vector<int>& B) {
        int la=A.size();
        int lb=B.size();
        int dp[1100], ans=0;
//dp[i][j]表示A的前i个元素形成的数组与B的前j个元素的数组的最长重复子数组个数，简化为一维dp[j]
        memset(dp,0,sizeof(dp));
        for(int i=1;i<=la;++i){
            for(int j=lb;j>=1;--j){
                if(A[i-1]==B[j-1]) dp[j]=dp[j-1]+1;
                else dp[j]=0;
                ans=max(ans,dp[j]);//因为只有连续才有值，故答案是所有值中的最大者，而不是最后者
            }
        }
        return ans;
    }
};

 7.2

【强行广搜】有序矩阵中第K小的元素-力扣

　　一眼就能看出这是道排序题，且数据是部分有序的，正常做法是暴力排序、归并排序、二分查找。写题的时候傻了，居然每层循环sort了一次，生生给stl排序的时间复杂度乘了个n[扶额]……当时一拍脑袋，莫非这题不是在考排序查找？于是反手写了一个广搜，把元素从左上角依次加入优先队列，虽然慢点，但过了。有被自己的脑回路笑到，罢，就当复习广搜算了。

参考代码：

//正常暴力排序(其他复杂度较小的排序用别的题练吧，此题不写了)
class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int n=matrix.size();
        vector<int> my;
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                my.push_back(matrix[i][j]);
            }
        }
        sort(my.begin(),my.end());
        return my[k-1];
    }
};

//非常规做法—广搜
class Solution {
public:
    struct Node{
        int x, y, v;
        Node(){}
        Node(int i, int j, int vv):x(i),y(j),v(vv){}
        bool operator < (Node b) const {
            return v>b.v;//变成小顶堆
        }
    };
    bool vis[300][300];
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        int n=matrix.size(), cnt=0;
        priority_queue<Node> my;
        memset(vis, 0, sizeof(vis));
        vis[0][0]=1;
        my.push(Node(0,0,matrix[0][0]));
        while(!my.empty()){
            cnt++;
            Node tmp=my.top();
            if(cnt==k) return tmp.v;
            int tx=tmp.x, ty=tmp.y;
            my.pop();
            if(tx+1<n && !vis[tx+1][ty]){
                my.push( Node(tx+1, ty, matrix[tx+1][ty]) );
                vis[tx+1][ty]=1;
            }
            if(ty+1<n && !vis[tx][ty+1]){
                my.push( Node(tx, ty+1, matrix[tx][ty+1]) );
                vis[tx][ty+1]=1;
            }
        }
        return -1;
    }
};

 刚刚看到Sun君的优先队列解法很棒，mark一下。神奇版代码：

class Solution {
public:
    int kthSmallest(vector<vector<int>>& matrix, int k) {
        priority_queue<int> pq;
        for (int i = 0; i < matrix.size(); ++i) {
            for (int j = 0; j < matrix[0].size(); ++j) {
                pq.push(matrix[i][j]);
                if (pq.size() > k) pq.pop();
            }
        }
        return pq.top();
    }
};

 7.3

今天事有点多，终于把小组分工定了[呼]，明天补上！

7.4

【栈】有效的括号-力扣

　　思路：A.倒序遍历，先找到最右边的左括号，再二次遍历其右边的紧邻是否匹配；B.遍历，对左括号入栈，遇到匹配的右括号就弹出栈顶元素；栈顶不匹配或未匹配完时栈已经为空，返回false。优化：长度为0直接返回true，长度为奇数直接返回false。

B思路的参考代码：

class Solution {
public:
    bool isValid(string s) {
        int n=s.length();
        if(n%2) return false;
        if(!n) return true;
        stack<int> my;
        for(int i=0;i<n;++i){
            if(s[i]=='('|| s[i]=='['|| s[i]=='{') my.push(s[i]);
            else{
                if(my.empty()) return false;
                int tmp=(int)s[i] +(int)my.top();
                if(tmp==81||tmp==184||tmp==248) my.pop();//为了简便损失了可读性，这里实际上就是判断栈顶元素是否是当前元素的左括号
                else return false;
            }
        }
        if(!my.empty()) return false;
        return true;
    }
};

 【动规】最长有效括号-力扣

　　　dalao的三种思路，太妙了！①动规，状态转移方程极妙；②栈，先入栈虚拟头元素-1；③正序逆序两次遍历，动态储存左右括号的数量与最新答案

动规思路的参考代码：

class Solution {
public:
    int dp[21000];//记录结尾是右括号的 前i个字符中最长有效括号位数
    int ans=0;
    int longestValidParentheses(string s) {
        int n=s.length();
        if(n==0) return 0;
        memset(dp,0,sizeof(dp));
        if(s[0]=='(' && s[1]==')') dp[1]=2;
        for(int i=2;i<n;++i){
            if(s[i]=='(') continue;//结尾是左括号的直接=0，实际上也阻断了前面连续有效括号对后面计数的影响，这个0值起到了分隔的作用
            if(s[i-1]=='(') dp[i]=dp[i-2]+2;//最右边恰好是一对括号
            else if(i-1-dp[i-1]>=0 && s[i-1-dp[i-1]]=='('){//最右边是两个右括号，向前找靠右侧的右括号对应的左括号，能找到则分几段计数(理解重点)
                dp[i]=dp[i-1]+2;
                if(i-2-dp[i-1]>=0) dp[i]+=dp[i-2-dp[i-1]];
            }
        }
        for(int i=0;i<n;++i){
            ans=max(ans,dp[i]);
        }
        return ans;
    }
};

 【递归回溯】括号生成-力扣

参考代码：

class Solution {
public:
    vector<string> my;
    int Max=-1;//设一个全局变量记录需要的最大左(右)括号数
    void gen(string s, int k, int l, int r){//k是剩余递归层数，l和r分别记录当前左右括号个数。基本原则是在每层递归，Max>=左括号数>=右括号数
        if(k==0){
            my.push_back(s);
            return;
        }
        if(l==r){
            gen(s+"(", k-1, l+1, r);
        }
        else{
            if(l<Max) gen(s+"(", k-1, l+1, r);
            gen(s+")", k-1, l, r+1);
        }
        return;
    }
    vector<string> generateParenthesis(int n) {
        Max=n;
        gen("", 2*n, 0, 0);
        return my;
    }
};

 7.5

【匹配】通配符匹配-力扣

　　这题写的真心心累……13次提交终于通过，真的是面向测试样例编程了hhh 歇够了再去看dalao更好的题解。

　　自己的两种思路：①递归/去除连续的 '*' 之后的递归，对具体字母和 '?' 匹配一个字符，不匹配return false，对 '*' 递归匹配。但这两种写法都会超时；

　　②对模式串中的具体字符块搜索匹配。先忽略模式串中的'*'，对字母和?搜索最近的匹配，不能匹配的/匹配串未匹配完的return false。但对特殊情况的处理超级麻烦，列举几个特殊情况：a.模式串尾部有*，但匹配串未匹配完，不能返回false；b.模式串头部无*，其余部分都能匹配上，但匹配串头部有未匹配部分，要返回false……另外，要非常小心访问越界。

参考代码：

class Solution {
public:
    int myRuntime=0;//用来记录是否是第一个匹配块，处理模式串头部无*，匹配串头部未匹配的特殊情况
    int myfind(int from, string ss, string pp){
        myRuntime++;
        int lst_loc=-1, lss=ss.length();
        for(int i=from;i<lss;++i){
            for(int j=0;j<pp.length();++j){
                if(i+j>=lss) return -1;
                if(ss[i+j]!=pp[j] && pp[j]!='?') break;
                if(j==pp.length()-1){
                    lst_loc=i+j;
                    return lst_loc;
                }
            }
        }
        return -1;
    }
    bool isMatch(string s, string p) {
        int ls=s.length(), lp=p.length();
        if(ls==0){
            for(int i=0;i<lp;++i){
                if(p[i]!='*') return false;
            }
            return true;
        }
        if(lp==0) return false;
        int ptr=0, lstres=0;
        string ptmp="";
        for(int i=0;i<lp;++i){
            while(p[i]!='*' && i<lp){
                ptmp+=p.substr(i,1);
                i++;
            }
            if(ptmp!=""){
                int itmp=myfind(ptr, s, ptmp);
                if(myRuntime==1 && p[0]!='*' && itmp+1-ptmp.length()!=0) return false;
                if(itmp==-1) return false;
                else ptr=itmp+1;
            }
            ptmp="";
        }
        if(ptr!=ls && p[lp-1]!='*'){
            string ptmp2="";
            int lpp=ptmp2.length(), i2=0;
            for(i2=lp-1;i2>=0;--i2){
                if(p[i2]=='*') break;
                while(i2>=0 && p[i2]!='*'){
                    ptmp2=p.substr(i2,1)+ptmp2;
                    i2--;
                }
                if(i2<0 || p[i2]=='*') break;
            }
            lpp=ptmp2.length();
            for(int j=0;j<lpp;++j){
                if(ls-1-j<0 || s[ls-1-j]!=ptmp2[lpp-1-j] && ptmp2[lpp-1-j]!='?') return false;
            }
            if(i2<0 || p[i2]!='*') return false;
        }
        return true;
    }
};

 7.6

 7.7

 7.8

【动规-水题】三步问题-力扣

　　优化存储空间！

参考代码：

class Solution {
public:
    int waysToStep(int n) {
        int a=1, b=2, c=4, ans=a+b+c;
        if(n<3) return n;
        if(n==3) return 4;
        n=n-3;
        while(n--){
            ans=((a+b)%1000000007+c)%1000000007;
            a=b;
            b=c;
            c=ans;
        }
        return ans;
    }
};

 7.9

【动规】恢复空格-力扣

　　①动规的思路比较常规，关键是剪枝：1.判断有效的单词长度（直接用set存储所有效的长度即可，也可以再加长度上下界的判断）；2.已为0的dp[i]直接continue

　　②另一种思路是“字典树”，稍后整理。

参考代码：

//法1：动规，根据有效的单词长度进行状态转移
class Solution {
public:
    int min_res[1000];//对前下标<=k的k个字符形成的串断句，能达到的最小未识别字符数
    int sml=2000, big=0;
    int min(int a, int b){
        if(a<=b) return a;
        return b;
    }
    int max(int a, int b){
        if(a>=b) return a;
        return b;
    }
    int respace(vector<string>& dictionary, string sentence) {
        int slen=sentence.length(), dlen=dictionary.size();
        if(dlen==0 || slen==0) return slen;
        set<string> newdic;
        set<int> mylen;
        for(string str : dictionary){
            newdic.insert(str);
            mylen.insert(str.length());
        }
        for(int i=0;i<dlen;++i){
            sml=min(sml,dictionary[i].length());
            big=max(big,dictionary[i].length());
            newdic.insert(dictionary[i]);
        }
        for(int k=0;k<slen;++k){
            string tmp;
            tmp.assign(sentence, 0, k+1);
            if(newdic.find(tmp)!=newdic.end()) min_res[k]=0;
            else min_res[k]=k+1;
            for(int i=sml;i<=k && i<=big;++i){
                if(mylen.find(i)==mylen.end()) continue;
                tmp.assign(sentence, k-i+1, i);
                if(newdic.find(tmp)!=newdic.end()) min_res[k]=min(min_res[k], min_res[k-i]);
            }
            for(int i=1;;++i){
                if(k-i<0) break;
                if(i>=min_res[k]-min_res[k-i]) break;
                min_res[k]=min(min_res[k], min_res[k-i]+i);
            }
        }
        return min_res[slen-1];
    }
};

……（这几天都有做题，参加了两场周赛，有点疲于总结了，不好不好。赶快补上啊）

 7.13

【二叉树】重建二叉树-力扣

　　复习二叉树构建和遍历的好题。①自己的方法，额外开了内存进行递归，慢且笨拙；②dalao的方法-自己复刻了一遍，巧用STL的find函数，用指针传参也很有魅力hhh

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
//法①
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n=preorder.size();
        TreeNode* root= new TreeNode;
        root->right=new TreeNode;
        root->left =new TreeNode;
        if(n<=1){
            if(n==0) root=NULL;
            else{
                root->val=preorder[0];
                root->right=NULL;
                root->left=NULL;
            }
            return root;
        }
        root->val=preorder[0];
        vector<int> pretmp1;
        vector<int> pretmp2;
        vector<int> intmp1;
        vector<int> intmp2;
        bool find=false;
        for(int i=0;i<n;++i){
            if(inorder[i]==preorder[0]){
                find=true;
                if(i>0) pretmp1.push_back(preorder[i]);
            }
            else if(!find){
                if(i>0) pretmp1.push_back(preorder[i]);
                intmp1.push_back(inorder[i]);
            }
            else{
                pretmp2.push_back(preorder[i]);
                intmp2.push_back(inorder[i]);
            }
        }
        root->left =buildTree(pretmp1, intmp1);
        root->right=buildTree(pretmp2, intmp2);
        return root;
    }
};

//法②
/*
*注：学习了TheoWu的做法，自己重写的
*链接：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/solution/cjian-dan-shi-xian-di-gui-by-theowu/
*/
class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return Build(preorder.begin(),preorder.end(),inorder.begin(),inorder.end());
    }
    TreeNode* Build(vector<int>::iterator pre_s, vector<int>::iterator pre_e, vector<int>::iterator in_s, vector<int>::iterator in_e){
        if(pre_s==pre_e) return NULL;
        TreeNode* cur=new TreeNode(*pre_s);
        auto root=find(in_s, in_e, *pre_s);
        cur->left =Build(pre_s+1, pre_s+1+(root-in_s), in_s, root);
        cur->right=Build(pre_s+1+(root-in_s), pre_e, root+1, in_e);
        return cur;  
    }
};

 7.14

【位运算复习】二进制中1的个数-力扣

　　水题，练手感……今天没做难题，在找实习了555

参考代码：

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int cnt=0;
        for(int i=0;i<=31;++i){
            if(n&(1<<i)) cnt++;
        }
        return cnt;
    }
};

 7.15

【动规-二叉搜索树】不同的二叉搜索树-力扣

　　初步解锁二叉搜索树！此题递归方法的思路自己想出来了，可以引申学习一下卡塔兰数。

参考代码：

/*
二叉查找树(Binary Search Tree)，(又:二叉搜索树，二叉排序树) 
它或者是一棵空树，或者是具有下列性质的二叉树: 
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值; 
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值; 
它的左、右子树也分别为二叉查找树。
*/
//法① 动规
class Solution {
public:
    int Max=0;
    int dp[1000];
    int f(int k){
        if(dp[k]>0 || k==0) return dp[k];
        dp[k]=f(k-1)*2;
        for(int i=1;i<=k-1;++i){
            dp[k]+=f(k-i-1)*f(i);
        }
        return dp[k];
    }
    int numTrees(int n) {
        memset(dp,0,sizeof(dp));
        dp[1]=1;
        dp[2]=2;
        dp[3]=5;
        Max=n;
        return f(n);
    }
};

//法② 卡塔兰数计算（力扣提供）

class Solution {
public:
    int numTrees(int n) {
        long long C = 1;
        for (int i = 0; i < n; ++i) {
            C = C * 2 * (2 * i + 1) / (i + 2);
        }
        return (int)C;
    }
};

 7.16

【深搜】判断二分图-力扣

　　啊我解锁二分图了！顺带学了点并查集的概念（好机智啊这种数据结构）。此题的两种思路是①深搜/广搜；②并查集。

　　匈牙利算法（判断是否图里还有交错的路径）

参考代码：

//深搜C++代码
class Solution {
public:
    bool vis[1000];
    int col[1000];
    int n;
    bool ans=true;
    void dfs(int k, int c, vector<vector<int>>& graph){
        if(!ans) return;
        if(graph[k].size()==0) return;
        for(int j=0;j<graph[k].size();++j){
            int i=graph[k][j];
            if(i==k) continue;
            if(vis[i]==1){
                if(col[i]==1-c) continue;
                ans=false;
                return;
            }
            vis[i]=1;
            col[i]=1-c;
            dfs(i, 1-c, graph);
        }
        return;
    }
    bool isBipartite(vector<vector<int>>& graph) {
        memset(vis, 0, sizeof(vis));
        memset(col, -1, sizeof(col));
        n=graph.size();
        for(int i=0;i<n;++i){
            for(int j=0;j<graph[i].size();++j){
                if(vis[graph[i][j]]) continue;
                dfs(graph[i][j], 0, graph);
            }
        }
        return ans;
    }
};

//dalao的Java代码，下次补上自己的C++/Python代码
class Solution {
    public boolean isBipartite(int[][] graph) {
        // 初始化并查集
        UnionFind uf = new UnionFind(graph.length);
        // 遍历每个顶点，将当前顶点的所有邻接点进行合并
        for (int i = 0; i < graph.length; i++) {
            int[] adjs = graph[i];
            for (int w: adjs) {
                // 若某个邻接点与当前顶点已经在一个集合中了，说明不是二分图，返回 false。
                if (uf.isConnected(i, w)) {
                    return false;
                }
                uf.union(adjs[0], w);
            }
        }
        return true;
    }
}

// 并查集
class UnionFind {
    int[] roots;
    public UnionFind(int n) {
        roots = new int[n]; 
        for (int i = 0; i < n; i++) {
            roots[i] = i;
        }
    }

    public int find(int i) {
        if (roots[i] == i) {
            return i;
        }
        return roots[i] = find(roots[i]);
    }

    // 判断 p 和 q 是否在同一个集合中
    public boolean isConnected(int p, int q) {
        return find(q) == find(p);
    }

    // 合并 p 和 q 到一个集合中
    public void union(int p, int q) {
        roots[find(p)] = find(q);
    }
}

 7.17

【复习-二分】第一个错误的版本-力扣

　　等hr（！后来发现是老板）开完会打面试电话ing……刷会题好了。这道题的测试点比较强，所以二分的条件一定要卡好，另外注意一下大整数相加除以2防止溢出的问题

参考代码：

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);

class Solution {
public:
    int firstBadVersion(int n) {
        int l=0, r=n, m;
        while(l<r){
            m=l/2+r/2+1;
            if(isBadVersion(m)) r=m-1;
            else l=m;
        }
        if(isBadVersion(l)) return l;
        return l+1;
    }
};

7.18

7.19

7.20

7.21

7.22

【二分】旋转数组的最小值-力扣

　　这几天有收到好消息诶。加油！此题是为了考二分而考二分，不许偷偷排序。总体思路是，被“简单洗牌”的数据，前半部分一定大于等于后半部分。

　　值得注意的点是，重复元素会非常干扰二分查找边界，可以在遇到时先去重，或对区间再二分搜索判断。

参考代码：

//没有去重，对重复点的区间查找
class Solution {//类似于简单洗牌
public:
    int minArray(vector<int>& numbers) {
        int n=numbers.size();
        int s=numbers[0], l=0, r=n-1;
        while(r-l>2){
            int t=l/2+r/2;
            if(numbers[t]<s) r=t;
            else if(numbers[t]>s) l=t;
            else{//重复！查找该点到结尾是否为包含答案的区间，注意1个ans+(N-1)个x的特殊情况
                int p=t;
                while(numbers[p]==s){
                    p++;
                    if(p==n-1){
                        if(numbers[n-1]==s) r=t-1;
                        else l=t+1;
                        break;
                    }
                }
                if(p!=n-1) l=t+1;
            }
        }
        for(int i=l-3;i<=l+3;++i){
            if(i<0||i>=n) continue;
            if(numbers[i]<s) return numbers[i];
        }
        return s;
    }
}

 8.11

【二叉树】二叉树的层序遍历-力扣

　　今天开始要尽快做完二叉树tag！

　　这道题看了提示做出来的，多开一个变量num记录下一层放入的节点个数，每次在队列里处理前num个节点。

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > levelOrder(TreeNode* root) {
        vector<vector<int> > ans;
        if(!root) return ans;

        queue<TreeNode*> q;
        q.push(root);
        int num=1;

        while(!q.empty()){
            int ntmp=0;
            vector<int> vtmp;
            for(int i=0;i<num;++i){
                TreeNode* k=q.front();
                q.pop();
                vtmp.push_back(k->val);
                if(k->left){
                    q.push(k->left);
                    ntmp++;
                }
                if(k->right){
                    q.push(k->right);
                    ntmp++;                    
                }
            }
            ans.push_back(vtmp);
            num=ntmp;
        }

        return ans;
    }
};

 8.12

【深搜/图】克隆图-力扣

　　这道题迫使人用哈希表标记访问过的点，因此创建了一个unordered_map<Node*, Node*>，还蛮有意思的一题。刚开始没做出来，看了解答后自己又敲了三遍代码↓

参考代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    unordered_map<Node*, Node*> vis;
    Node* cloneGraph(Node* node) {
        if(!node) return NULL;
        if(vis.find(node)!= vis.end()) return vis[node];//先返回这种情况会比较快

        Node* Cnode = new Node(node->val);//别忘了new
        vis[node] = Cnode;//!!

        for(auto x = node->neighbors.begin(); x!=node->neighbors.end(); ++x){
            Cnode->neighbors.push_back(cloneGraph(*x));
        }
        return Cnode;
    }
};

 8.13——今天是左撇子日喔！祝左撇子朋友们节日快乐啊[跳跳]

【字符串】字符串相乘-力扣

　　复习大整数乘法。注：对两个大整数，每两位直接相乘，先将整数存储到答案数组对应的位置上、再逐位进制会较快，另外要多预留首一位，在不需要进一位时通过判断去掉。

参考代码：

class Solution {
public:
    string Int2String(int x){
        string s = "?";
        s[0] = '0'+x;
        return s;
    }
    string multiply(string num1, string num2) {
        if (num1 == "0" || num2 == "0") {
            return "0";
        }
        int m = num1.size(), n = num2.size();
        vector<int> ansArr( m+n, 0 );//声明vector时预设长度的一种方法，长度为m+n，值均为0（0可以换成其他值）
        for(int i = m - 1; i >= 0; --i){
            for(int j = n - 1; j >= 0; --j){
                ansArr[i+j+1] += (num1[i]-'0') * (num2[j]-'0');
            }
        }
        for(int i = n + m - 1; i > 0; --i){
            ansArr[i - 1] += ansArr[i]/10;
            ansArr[i] %= 10;
        }        
    int p = 0;
    string ans = "";
    if (ansArr[0]==0) p+=1;
    while(p < n+m){
        ans = ans + Int2String(ansArr[p]);
        p++;
    }
    return ans;
    }
};

 【二叉树】填充每个节点的下一个右侧节点指针 II-力扣

　　题目要求用常数空间O(1)解答，使用的栈空间不计。故不能用广搜/队列（为啥我用了就超时了555），可以用递归。此题的关键是找到next节点，使用bro临时节点在函数中保存并传参。next指针本身就带有方向，所以和队列存储的原理是一致的。

参考代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}
    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution {
public:
    void Run(Node* root, Node* cousin){
        if(!root) return;
        Node* bro = cousin;//临时变量bro用来记录和root子节点同一层（即root的下一层）的右边最靠近的节点
        if(root->right){
            while(bro!=NULL){//while循环的意义是往右走，往下走，直到找到下一层第一个节点
                if(bro->left){
                    bro = bro->left;
                    break;
                }
                if(bro->right){
                    bro = bro->right;
                    break;
                }
                bro = bro->next;
            }
            (root->right)->next = bro;
            if(root->left) (root->left)->next = (root->right);
            Run(root->right, bro);
            Run(root->left, root->right);
        }
        else if(root->left){
            while(bro!=NULL){
                if(bro->left){
                    bro = bro->left;
                    break;
                }
                if(bro->right){
                    bro = bro->right;
                    break;
                }
                bro = bro->next;
            }
            if(root->right){
                (root->right)->next = bro;
                (root->left)->next = (root->right);                
            }
            else{
                (root->left)->next = bro;
            }
            Run(root->left, (root->left)->next);
            Run(root->right, bro);
        }
        return ;
    }
    Node* connect(Node* root) {
        Run(root, NULL);
        return root;
    }
};

 【二叉树】二叉树的最近公共祖先-力扣

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root || root == p || root == q) return root;
        TreeNode* l = lowestCommonAncestor(root->left, p, q);
        TreeNode* r = lowestCommonAncestor(root->right, p, q);
        //当l和r都不为NULL时，只有一种可能，说明p, q与root直接相连，在其左右两侧，应返回root;
        //l和r不可能都为NULL（跟丢了p和q）
        //故，当r、l其中一个为NULL，应返回另一个值
        if(!l) return r;
        if(!r) return l;
        return root;
    }
};

 【二叉树】二叉树的序列化与反序列化-力扣

　　这题也太难了呜呜……下次应该先看看题目难度再做。参考了forgetthing大佬的代码，又加了点注释↓

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string res;
        dfs_s(root, res);
        return res;
    }

    // 前序遍历序列转化为字符串               //注：在字符串中加null和空格，就只需要一种遍历方式
    void dfs_s(TreeNode* root, string& res) {
        if (!root) {
            res += "null ";
            return;
        }
        res += to_string(root->val) + ' ';
        dfs_s(root->left, res);
        dfs_s(root->right, res);
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        // 开始遍历索引
        int u = 0;
        return dfs_d(data, u);
    }

    TreeNode* dfs_d(string& data, int& u) { //还要考虑多位整数的计算
        if (u >= data.size()) return NULL;
        if (data[u] == 'n') {
            u = u + 5;
            return NULL;
        }
        int val = 0, sign = 1;
        if (data[u] == '-') sign = -1, u ++ ;
        while(data[u] != ' '){val = val * 10 + data[u] - '0'; u++;}
        val *= sign;
        u = u + 1 ;

        auto root = new TreeNode(val);
        root->left = dfs_d(data, u);
        root->right = dfs_d(data, u);

        return root;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec codec;
// codec.deserialize(codec.serialize(root));

 8.14

　　今天也非常特殊，因为今天力扣的每日一题终于是一道做过的题了，而且今天进入新的tag啦，开启"二叉搜索树"！以后会有越来越多的题被做过啊

【二叉搜索树】验证二叉搜索树-力扣

　　这道题算是二叉搜索树入门级的练习，注意整数的边界一定要取满，是2147483648（1<<31）和-2147483648

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool judge(TreeNode* root, int up, int down, int upValid, int downValid){
        if(!root) return true;
        int ov = root->val;
        if(root->left){
            int lv = root->left->val;
            if( lv >= ov || (downValid && lv <= down) || (upValid && lv >= up) ) return false;
            if(!judge(root->left, min(ov, up), down, true, downValid) ) return false;
        }
        if(root->right){
            int rv = root->right->val;
            if( rv <= ov || (downValid && rv <= down) || (upValid && rv >= up) ) return false;
            if(!judge(root->right, up, max(ov, down), upValid, true) ) return false;
        }
        return true;
    }
    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        return judge(root, 2147483647, -2147483648, false, false);
    }
};

 【二叉搜索树】二叉搜索树迭代器-力扣

　　这题不难，主要考中序遍历。AC后看别人的题解，一大半都是用栈模拟，用vector的人好少hhh

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class BSTIterator {
public:
    vector<int> vals;
    int p;
    int len;
    BSTIterator(TreeNode* root){
        Inorder(root);
        p = 0;
        len = vals.size();
    }
    void Inorder(TreeNode* root){
        if(!root) return;
        if(root->left){
            Inorder(root->left);
        }
        vals.push_back(root->val);
        if(root->right){
            Inorder(root->right);
        }
        return;
    }
    /** @return the next smallest number */
    int next() {
        return vals[p++];
    }
    
    /** @return whether we have a next smallest number */
    bool hasNext() {
        return p < len;
    }
};

/**
 * Your BSTIterator object will be instantiated and called as such:
 * BSTIterator* obj = new BSTIterator(root);
 * int param_1 = obj->next();
 * bool param_2 = obj->hasNext();
 */

 8.17

【二叉树】平衡二叉树-力扣

　　优化递归效率：自顶而下=>自底而上

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

//法一：自顶而下
class Solution {
public:
    void cal(TreeNode* rt, int depth, int& ans){
        if(!rt) return;
        if( !(rt->left) && !(rt->right)){
            ans = max(ans, depth);
            return;
        }
        if(rt->left) cal(rt->left, depth+1, ans);
        if(rt->right) cal(rt->right, depth+1, ans);
        return;
    }
    int maxDepth(TreeNode* root) {
        int ans = 0;
        if(!root) return 0;
        cal(root, 1, ans);
        return ans;
    }
    bool isBalanced(TreeNode* root) {
        if(!root) return true;
        int t = maxDepth(root->left) - maxDepth(root->right);
        if(t<-1 || t>1) return false;
        if(!isBalanced(root->left)) return false;
        if(!isBalanced(root->right)) return false;
        return true;
    }
};

//法二：自底而上
class Solution {
public:
    int cal_h(TreeNode* root){
        if(!root) return 0;
        int rh = cal_h(root->right);
        int lh = cal_h(root->left);
        if(rh == -1 || lh == -1 || abs(rh-lh)>1 ) return -1; //返回值非常巧妙！
        return max(1+rh, 1+lh);
    }
    bool isBalanced(TreeNode* root) {
        return cal_h(root)>=0;
    }
};

 【二叉树】删除二叉搜索树中的节点-力扣

　　这题还真是有那么点意思。分三种情况，①删除叶子节点，直接删；②存在右子树（也就存在中序后继节点），用中序后继节点的值赋值（或交换，注意一下后面待删除节点的值），然后在右子树中递归删除中序后继节点；③存在左子树（也就存在中序前缀节点），用中序前缀节点的值赋值，然后在左子树中递归删除中序前缀节点

　　另外，卡住半天的地方是递归删除时，参数应该传root的左（右）子树的根节点，并把返回值赋给左（右）子树的根节点。

参考代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* findPre(TreeNode* root){//找中序前缀节点
        root = root->left;
        while(root->right){
            root = root->right;
        }
        return root;
    }
    TreeNode* findNext(TreeNode* root){//找到中序后继节点
        root = root->right;
        while(root->left){
            root = root->left;
        }
        return root;
    }
    TreeNode* deleteNode(TreeNode* root, int key) {
        if(!root) return NULL;
        if(root->val == key){
            if(!root->left && !root->right){//要删除的是叶子节点
                root = NULL;
                return root;
            }
            else if(root->right){//要删除的节点存在右孩子，用后继节点的值补充
            //右子树向下递归删除该后继节点，后继节点一定没有右孩子
            TreeNode* tmp = findNext(root);
                root->val = tmp->val;
                root->right = deleteNode(root->right, tmp->val);
                return root;
            }
            else if(root->left){//要删除的节点存在左孩子，用前缀节点的值补充
            //左子树向下递归删除该前缀节点，前缀节点一定没有左孩子
            TreeNode* tmp = findPre(root);
                root->val = tmp->val;
                root->left = deleteNode(root->left, tmp->val);
                return root;
            }
        }
        else if(root->val < key){
            root->right = deleteNode(root->right, key);
            return root;
        }
        else{
            root->left = deleteNode(root->left, key);
            return root;
        }
        return root;
    }
};

 8.18

【二叉树】有序链表转换二叉树-力扣

　　这道题与二叉平衡树的构造密切相关，注意构造的方式不唯一。用类似于二分的方法构造平衡二叉树，其合理性和效率可以得到证明。

参考代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
/**
 * 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* helper(vector<int>& nums, int left, int right) {
        if (left > right) {
            return nullptr;
        }
        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = helper(nums, left, mid - 1);
        root->right = helper(nums, mid + 1, right);
        return root;
    }
    TreeNode* sortedListToBST(ListNode* head) {
        vector<int> nums;
        while(head){
            nums.push_back(head->val);
            head = head->next;
        }
        return helper(nums, 0, nums.size() - 1);
    }
};

 8.21

【二叉树】数据流中的第K大元素-力扣

　　第一次用二叉搜索树的形式完成这种题hh，耗时还真是……一言难尽啊。贴一下自己和大佬YouLookDeliciousC 的代码，大佬在构建树时就已经开始计数了，更快，没有对比没有伤害诶

参考代码：

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest* obj = new KthLargest(k, nums);
 * int param_1 = obj->add(val);
 */

//1.自己的代码，很笨拙，为了处理特殊情况不得不增加全局变量
class KthLargest {
public:
    class MyTree{
        public:
            int val;
            MyTree* left = NULL;
            MyTree* right = NULL;
            MyTree(int x):val(x){}
            MyTree(){}
    };
    MyTree* build(MyTree* root, vector<int>& nums, int s, int e){
        if(s>=e) return NULL;
        int t = (e+s)/2;
        if(root==NULL){
            root = new MyTree(nums[t]);
        }
        else root->val = nums[t];
        root->left = build(root->left, nums, s, t);
        root->right = build(root->right, nums, t+1, e);
        return root;
    }

    int cnt = 0, ans = -1, key = -1, len = -1;
    MyTree* Myroot = new MyTree(-1);
    bool empty = true;

    void help(MyTree* root, int val){
        if(!root){
            root = new MyTree(val);
            return;
        }
        if(root->val < val){
            if(!root->right){
                root->right = new MyTree(val);
                return;
            }
            help(root->right, val);
            return;
        }
        else{
            if(!root->left){
                root->left = new MyTree(val);
                return;
            }
            help(root->left, val);
            return;
        }
        return;
    }

    void Scan(MyTree* s){
        if(!s) return;
        Scan(s->right);
        cnt++;
        if(cnt == key){
            ans = s->val;
            return;
        }
        else if (cnt>key){
            return;
        }
        Scan(s->left);
        return;
    }

    KthLargest(int k, vector<int>& nums) {
        key = k;
        len = nums.size();
        if(len>0) empty = false;
        sort(nums.begin(), nums.end());
        Myroot = build(Myroot, nums, 0, len );
    }
    
    int add(int val) {
        cnt = 0;
        ans = -1;
        if(empty){
            Myroot = new MyTree(val);
            empty = false;
        }
        else help(Myroot, val);
        Scan(Myroot);
        return ans;
    }
};

//2.大佬的代码，简洁！
class KthLargest {
    struct TreeNode{
        int val;
        int count; // 用以记录以包括当前节点，左右子树在内。有多少个节点。
        TreeNode* left;
        TreeNode* right;
        TreeNode(int x): val(x), left(NULL), right(NULL), count(1) {}
    };
public:

    int K;
    TreeNode* root;
    TreeNode* addNode(TreeNode* root, int val){ // 构建二叉搜索树
        if(!root)   return new TreeNode(val);
        if(val <= root -> val){ //如果子树的点加一，该节点的count值加一
            root -> count += 1;
            root -> left = addNode(root -> left, val);
        }else{
            root -> count += 1;
            root -> right = addNode(root -> right, val);
        }
        return root;
    }
    int findNum(TreeNode* treeRoot, int k){
        int m = 1;
        if(treeRoot -> right)   m = treeRoot -> right -> count + 1; //m是root加上右子树的所有节点的数量
        if(k == m)  return treeRoot -> val;
        if(k < m) { // 右子树的节点大于k，目标点在右子树
            return findNum(treeRoot -> right, k);
        }
        else{
            return findNum(treeRoot -> left, k - m); //右子树的节点加上根节点小于k个，目标点在左子树
        }
    }


    KthLargest(int k, vector<int>& nums): K(k), root(NULL) {
        for(auto i : nums){ //创建二叉搜索树
            root = addNode(root, i);
        }
    }
    
    int add(int val) {
        root = addNode(root, val); //更新子树
        return findNum(root, K);
    }
};

 9.16

【二分法&快慢指针】寻找重复数-力扣

　　挺神奇的一道题，在限制了大小为n+1的数组中只含有1~n的数后，有很多解法。挑两种总结一下下：

①二分法（有点强行二分的意思）

　　“我们定义cnt[i] 表示nums[] 数组中小于等于 i 的数有多少个，假设我们重复的数是 target，那么[1,target−1]里的所有数满足 cnt[i]≤i，[target,n] 里的所有数满足cnt[i]>i，具有单调性。” ——力扣

②快慢指针（Floyd 判圈算法）

　　此方法真的惊艳。使用条件为，图中存在环。

　　操作：

　　“我们先设置慢指针slow 和快指针 fast ，慢指针每次走一步，快指针每次走两步，根据「Floyd 判圈算法」两个指针在有环的情况下一定会相遇，此时我们再将slow 放置起点 0，两个指针每次同时移动一步，相遇的点就是答案。”  ——力扣

　　原理：

　　“假设环长为 L，从起点到环的入口的步数是 a，从环的入口继续走 b 步到达相遇位置，从相遇位置继续走 c 步回到环的入口，则有 b+c=L，其中 L、a、b、c 都是正整数。根据上述定义，慢指针走了 a+b 步，快指针走了 2(a+b) 步。从另一个角度考虑，在相遇位置，快指针比慢指针多走了若干圈，因此快指针走的步数还可以表示成 a+b+kL，其中 k 表示快指针在环上走的圈数。联立等式，可以得到

2(a+b)=a+b+kL

解得 a=kL−b，整理可得

a=(k-1)L+(L-b)=(k-1)L+c

从上述等式可知，如果慢指针从起点出发，快指针从相遇位置出发，每次两个指针都移动一步，则慢指针走了 a 步之后到达环的入口，快指针在环里走了 k−1 圈之后又走了 c 步，由于从相遇位置继续走 c 步即可回到环的入口，因此快指针也到达环的入口。两个指针在环的入口相遇，相遇点就是答案。”

——力扣

快慢指针法参考代码：

class Solution {
public:
    int findDuplicate(vector<int>& nums) {
        int slow = 0, fast = 0;
        do {
            slow = nums[slow];
            fast = nums[nums[fast]];
        } while (slow != fast);
        slow = 0;
        while (slow != fast) {
            slow = nums[slow];
            fast = nums[fast];
        }
        return slow;
    }
};

-------------1个月100道题的flag倒了，抽空继续完成。现在在准备几天后基于HackerRank的1h笔试网测-------------------- 

9.26

【数组&排序】New Year Chaos -HackerRank

　　容易超时，需要精确优化。自己的两种思路，仅供参考：①逆序对的数量就是答案，但是用两层循环计数、一半测试点会超时；②原题可看做“冒泡打乱”，就用冒泡排序还原，记录交换位置的次数。注意要不断优化冒泡排序的区间。

参考代码：

#include <bits/stdc++.h>
using namespace std;
vector<string> split_string(string);

// Complete the minimumBribes function below.//只需完成此函数代码
void minimumBribes(vector<int> q){
    int ans = 0, len = q.size();
    vector<int> pre(len, 0);
    for(int i = 0; i < len; ++i){
        if(q[i] - (i+1) > 2){
            cout<<"Too chaotic"<<endl;
            return;
        }
    }
    int s = 0, e = len - 1;
    while(s<e){
        while(s < e && q[s] == s+1){
            s++;
        }
        if(s >= e) break;
        for(int i = s; i < e; ++i){
            if(q[i] > q[i+1]){
                ans += 1;
                swap(q[i], q[i+1]);
            }
        }
    }
    cout<<ans<<endl;
    return;
}

int main()
{
    int t;
    cin >> t;
    cin.ignore(numeric_limits<streamsize>::max(), '
');

    for (int t_itr = 0; t_itr < t; t_itr++) {
        int n;
        cin >> n;
        cin.ignore(numeric_limits<streamsize>::max(), '
');

        string q_temp_temp;
        getline(cin, q_temp_temp);

        vector<string> q_temp = split_string(q_temp_temp);

        vector<int> q(n);

        for (int i = 0; i < n; i++) {
            int q_item = stoi(q_temp[i]);

            q[i] = q_item;
        }

        minimumBribes(q);
    }

    return 0;
}

vector<string> split_string(string input_string) {
    string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
        return x == y and x == ' ';
    });

    input_string.erase(new_end, input_string.end());

    while (input_string[input_string.length() - 1] == ' ') {
        input_string.pop_back();
    }

    vector<string> splits;
    char delimiter = ' ';

    size_t i = 0;
    size_t pos = input_string.find(delimiter);

    while (pos != string::npos) {
        splits.push_back(input_string.substr(i, pos - i));

        i = pos + 1;
        pos = input_string.find(delimiter, i);
    }

    splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));

    return splits;
}