从零开始的刷LeetCode生活 第8期 81-90

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        while(l <= r)
        {
            while(l < r && nums[l] == nums[l + 1]) l ++;
            while(l < r && nums[r] == nums[r - 1]) r --;
            int mid = l + r >> 1; //要用到mid 所以上面 l <= r
            if(nums[mid] == target) return true;
            if(nums[mid] >= nums[l]){
                if(target < nums[mid] && target >= nums[l]) r = mid;
                else l = mid + 1;
            }
            else{
                if(target > nums[mid] && target <= nums[r]) l = mid + 1;
                else r = mid;
            }
        }
        return false;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        ListNode* dummy = new ListNode(-1);
        dummy->next = head;
        ListNode* p = dummy;
        while(p->next)
        {
            ListNode* q = p->next;
            while(q && q->val == p->next->val)
                q = q->next;
            if(p->next->next == q) p = p->next;
            else p->next = q;
        }
        return dummy->next;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(!head) return 0;
        ListNode* p = head, *q = head;
        while(p)
        {
            if(p->val != q->val)
            {
                q->next = p;
                q = p;
            }
            p = p->next;
        }
        q->next = NULL;
        return head;
    }
};

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        int n = heights.size(), res = 0;
        heights.push_back(-1); //在数组末尾添加高度-1 
        stack<int> stk;
        for(int i = 0; i <= n; i ++)
        {
            while(!stk.empty() && heights[i] < heights[stk.top()])
            {
                int cur = stk.top();
                stk.pop();
                if(stk.empty())
                    res = max(res, heights[cur] * i);
                else
                    res = max(res, heights[cur] * (i - stk.top() - 1));
            }
            stk.push(i);
        }
        return res;
    }
};

class Solution {
public:
    int maximalRectangle(vector<vector<char>>& matrix) {
        //求出每一层的 heights[] 然后传给上一题的函数就可以了
        int n = matrix.size(), m, res = 0;
        if(n == 0) return 0;
        m = matrix[0].size();
        vector<int> heights(m + 1, 0);
        heights[m] = -1;
        for(int i = 0; i < n; i ++)
        {
            for(int j = 0; j < m; j ++)
                if(matrix[i][j] == '0')
                    heights[j] = 0;
                else
                    heights[j] ++;
            stack<int> stk;
            for(int j = 0; j <= m; j ++)
            {
                while(!stk.empty() && heights[j] < heights[stk.top()]){
                    int cur = stk.top();
                    stk.pop();
                    if(stk.empty())
                        res = max(res, heights[cur] * j);
                    else    
                        res = max(res, heights[cur] * (j - stk.top() - 1));
                }
                stk.push(j);
            }
        }
        return res;
    }
};

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* partition(ListNode* head, int x) {
        ListNode* before = new ListNode(-1);
        ListNode* after = new ListNode(-1);
        ListNode* pb = before, *pa = after;
        for(ListNode* p = head; p; p = p->next)
        {
            if(p->val < x)
            {
                pb->next = p;
                pb = p;
            }
            else{
                pa->next = p;
                pa = p;
            }            
        }
        pb->next = after->next;
        pa->next = 0;
        return before->next; 
    }
};

class Solution {
public:
    bool isScramble(string s1, string s2) {
        if(s1 == s2) return true;
        string ss1 = s1, ss2 = s2;
        sort(ss1.begin(), ss1.end()), sort(ss2.begin(), ss2.end());
        if(ss1 != ss2) return false;
        for(int i = 1; i < s1.size(); i ++)
        {
            if(isScramble(s1.substr(0, i), s2.substr(0, i)) &&
            isScramble(s1.substr(i), s2.substr(i)))
                return true;
            if(isScramble(s1.substr(0, i), s2.substr(s2.size() - i)) &&
            isScramble(s1.substr(i), s2.substr(0, s2.size() - i)))
                return true;
        }
        return false;
    }
};

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int k = n + m - 1;
        m --, n --;
        while(~m && ~n)
        {
            if(nums1[m] < nums2[n]) nums1[k --] = nums2[n --];
            else nums1[k --] = nums1[m --];
        }
        while(~n) nums1[k --] = nums2[n --];
    }
};

class Solution {
public:
    vector<int> grayCode(int n) {
        vector<int> res;
        for(int i = 0; i < 1 << n; i ++)
            res.push_back(i ^ (i >> 1));
        return res;
    }
};

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        dfs(nums, 0);
        return res;
    }

    void dfs(vector<int>&nums, int u)
    {
        if(u == nums.size())
        {
            res.push_back(path);
            return;
        }
        int k = u;
        while(k < nums.size() && nums[k] == nums[u]) k ++;
        dfs(nums, k);
        for(int i = u; i < k; i ++)
        {
            path.push_back(nums[i]);
            dfs(nums, k);            
        }
        while(path.size() && path.back() == nums[u]) path.pop_back();
    }
};