划分

参考了前令的博客。

class Solution {
public:
    void sortColors(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int left=0,mid=0,right=n-1;
        while(mid<=right){//最初写的是mid<right
            while(A[right]==2) right--;
            if(mid>right) break;//最初写的是mid>=right
            swap(A,right,mid);
            if(A[mid]==1) mid++;
            else{
                swap(A,left,mid);
                left++;
                mid++;
            }
        }
    }
    void swap(int A[],int i,int j){
        int tmp=A[i];
        A[i]=A[j];
        A[j]=tmp;
    }
};

[0,1]这种测试样例不过，修改程序mid<=right和mid>right

我自己写了个i从-1开始的版本，仿照快排的思想：

class Solution {
public:
    void sortColors(int A[], int n) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(A==NULL||n<=0) return;
        int i=-1,j=0,k=n-1;
        while(j<=k){
            while(A[k]==2) k--;
            if(j>k)  break;
            swap(A,k,j);
            if(A[j]==1) j++;
            else if(A[j]==0){
                i++;
                swap(A,i,j);
                j++;
            }
        }
    }
    void swap(int A[],int i,int j){
        int tmp=A[i];
        A[i]=A[j];
        A[j]=tmp;
    }
};

Recover Binary Search Tree

思路：中序遍历，使用n1,n2两个指针表示需要交换的两个节点

如何得到n1: 第一个比后续节点大的节点

如何得到n2: 最后一个前面节点大于后面节点

代码：

void proc(TreeNode *root, TreeNode *&n1, TreeNode *&n2, TreeNode *&prev)
{
    if(!root)
        return;
    proc(root->left,n1,n2,prev);
    if(prev && prev->val > root->val)
    {
        n2 = root;
        if(!n1)
            n1 = prev;
    }
    prev = root;
    proc(root->right,n1,n2,prev);
}
void recoverTree(TreeNode *root) {
    // Start typing your C/C++ solution below
    // DO NOT write int main() function
    TreeNode *n1 = NULL;
    TreeNode *n2 = NULL;
    TreeNode *prev = NULL;
    proc(root,n1,n2,prev);
    if(n1 && n2)
        swap(n1->val,n2->val);
}

Length of Last Word 

class Solution {
public:
    int lengthOfLastWord(const char *s) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(s==NULL) return 0;
        int res=0,len=strlen(s);
        int i=len-1;
        while(i>=0&&s[i]==' '){i--;}
        while(i>=0&&s[i]!=' '){res++;i--;}
        return res;
    }
};

search 2D Matrix

两次二分查找，时间复杂度为O(lgm)+O(lgn)

class Solution {
public:
    bool searchMatrix(vector<vector<int> > &matrix, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(matrix.empty()) return false;
        int row=matrix.size(),col=matrix[0].size();
        vector<int> vec;
        for(int i=0;i<row;i++)
            vec.push_back(matrix[i][col-1]);
        int pos=findFirstGreaterThan(vec,target);
        if(pos>=row) return false;
        else if(matrix[pos][col-1]==target)
            return true;
        else
            return bsearch(matrix[pos],target);
    }
    int findFirstGreaterThan(vector<int> &vec,int target){
        int l=0,r=vec.size()-1;
        while(l<=r){
            int mid=l+(r-l)/2;
            if(vec[mid]>target) r=mid-1;
            else if(vec[mid]==target) return mid;
            else
                l=mid+1;
        }
        return l;
    }
    bool bsearch(vector<int> &vec,int target){
        int l=0,r=vec.size()-1;
        while(l<=r){
            int mid=l+(r-l)/2;
            if(vec[mid]==target) return true;
            else if(vec[mid]<target) l=mid+1;
            else r=mid-1;
        }
        return false;
    }
};

Anagrams

class Solution {
public:
    map<string,int> mp;
    vector<string> anagrams(vector<string> &strs) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        vector<string> res;
        if(strs.empty()) return res;
        mp.clear();
        for(int i=0;i<strs.size();i++){
            string tmp=strs[i];
            sort(tmp.begin(),tmp.end());
            mp[tmp]++;
        }
        for(int i=0;i<strs.size();i++){
            string tmp=strs[i];
            sort(tmp.begin(),tmp.end());
            if(mp.count(tmp)&&mp[tmp]>1){
                res.push_back(strs[i]);
            }
        }
        return res;
    }
};

Scramble String

class Solution {
public:
    bool isScramble(string s1, string s2) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(s1.length()!=s2.length()) return false;
        if(s1.length()==1) return s1[0]==s2[0];
        string tmp1=s1,tmp2=s2;
        sort(tmp1.begin(),tmp1.end());
        sort(tmp2.begin(),tmp2.end());
        if(!comp(tmp1,tmp2)) return false;
        for(int i=1;i<s1.length();i++){
            string s11=s1.substr(0,i);
            string s12=s1.substr(i);
            string s21=s2.substr(0,i);
            string s22=s2.substr(i);
            if(isScramble(s11,s21)&&isScramble(s12,s22)) return true;
            s21=s2.substr(0,s1.length()-i);
            s22=s2.substr(s1.length()-i);
            if(isScramble(s11,s22)&&isScramble(s12,s21)) return true;
        }
        return false;
    }
    bool comp(string s1,string s2){
        for(int i=0;i<s1.length();i++)
            if(s1[i]!=s2[i]) return false;
        return true;
    }
};

Largest Rectangle in Histogram

 

class Solution {
public:
    int largestRectangleArea(vector<int> &height) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(height.empty()) return 0;
        int len=height.size(),res=0;
        int l[len],r[len];
        for(int i=0;i<len;i++){
            l[i]=i;
            while(l[i]-1>=0&&height[i]<=height[l[i]-1])
                l[i]=l[l[i]-1];
        }
        for(int i=len-1;i>=0;i--){
            r[i]=i;
            while(r[i]+1<len&&height[i]<=height[r[i]+1])
                r[i]=r[r[i]+1];
        }
        for(int i=0;i<len;i++)
            if((r[i]-l[i]+1)*height[i]>res)
                res=(r[i]-l[i]+1)*height[i];
        return res;
    }
};

Remove Duplicates from Sorted List II

 

class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(head==NULL) return NULL;
        ListNode *begin=head, *end=head,*pre=NULL,*res=NULL;
        int cnt=0,times=0;
        while(begin!=NULL){
            cnt=0;
            while(end!=NULL&&end->val==begin->val){
                end=end->next;
                cnt++;
            }
            if(cnt==1){
                times++;
                if(times==1) res=begin;
                if(pre==NULL) pre=begin;
                else{
                    pre->next=begin;
                    pre=begin;
                }
            }
            begin=end;
        }
        if(pre==NULL) return NULL;
        else{
            pre->next=NULL;
            return res;
        }
    }
};

Remove Duplicates from Sorted List

class Solution {
public:
    ListNode *deleteDuplicates(ListNode *head) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(head==NULL) return NULL;
        ListNode *begin=head, *end=head,*res=head;
        while(begin!=NULL){
            while(end!=NULL&&begin->val==end->val)
                end=end->next;
            begin->next=end;
            begin=end;
        }
        return res;
    }
};

Word Search 没想到可以一遍AC，超时的时候改了一下将flag置为了true

class Solution {
public:
    int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
    int vis[1000][1000];
    bool exist(vector<vector<char> > &board, string word) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        bool flag=false;
        memset(vis,0,sizeof(vis));
        for(int i=0;i<board.size();i++)
            for(int j=0;j<board[0].size();j++){
                if(board[i][j]==word[0]){
                    flag=false;
                    dfs(i,j,board,word,0,flag);
                    vis[i][j]=0;
                    if(flag) return true;
                }
            }
        return false;
    }
    
    void dfs(int x,int y,vector<vector<char> > &board,string word,int index,bool &flag){
        if(flag||board[x][y]!=word[index]) return;
        vis[x][y]=1;
        if(index==word.length()-1){flag=true;return;}
        for(int i=0;i<4;i++){
            int xx=x+dir[i][0];
            int yy=y+dir[i][1];
            if(xx>=0&&xx<board.size()&&yy>=0&&yy<board[0].size()&&vis[xx][yy]==0){
                vis[xx][yy]=1;
                dfs(xx,yy,board,word,index+1,flag);
                vis[xx][yy]=0;
            }
        }
    }
};

Rotate List:
有一点需要注意，k=0的时候

class Solution {
public:
    ListNode *rotateRight(ListNode *head, int k) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        if(head==NULL) return NULL;
        if(k==0) return head;
        int len=getLen(head);
        k=k%len;
        if(k==0) return head;
        ListNode *pre=NULL,*slow=head,*fast=head;
        for(int i=0;i<k-1;i++)
            fast=fast->next;
        while(fast->next!=NULL){
            fast=fast->next;
            pre=slow;
            slow=slow->next;
        }
        if(pre==NULL) return head;
        else{
            fast->next=head;
            pre->next=NULL;
            return slow;
        }
    }
    int getLen(ListNode *head){
        int res=0;
        while(head){
            res++;
            head=head->next;
        }
        return res;
    }
};

class Solution {
public:
    int sqrt(int x) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        long long l=0,r=x,mid,times=0;
        while(l<=r){
            mid=(l+r)/2;
            if(mid*mid>x) r=mid-1;
            else if(mid*mid<x) l=mid+1;
            else{
                return mid;
            }
        }
        return r;
    }
};