leetcode(81-85)

81. 搜索旋转排序数组 II

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,0,1,2,2,5,6] 可能变为 [2,5,6,0,0,1,2] )。

编写一个函数来判断给定的目标值是否存在于数组中。若存在返回 true，否则返回 false。

示例 1:

输入: nums = [2,5,6,0,0,1,2], target = 0
输出: true

示例 2:

输入: nums = [2,5,6,0,0,1,2], target = 3
输出: false

进阶:

• 这是 搜索旋转排序数组 的延伸题目，本题中的 nums  可能包含重复元素。
• 这会影响到程序的时间复杂度吗？会有怎样的影响，为什么？

class Solution {
public:
    bool search(vector<int>& nums, int target) {
        int begin = 0;
        int end = nums.size() -1;
        int i=0;
        
        while(begin <= end){
            for(i=begin; i<end && nums[i]==nums[i+1];i++);
            begin=i;
            for(i=end; i>begin && nums[i]==nums[i-1];i--);
            end=i;
            int mid = (begin+ end)/2;
            if(target == nums[mid])
                return true;
            else if(target < nums[mid]){
                if(nums[begin] < nums[mid]){
                    if(target >= nums[begin]){
                        end = mid -1;
                    }else{
                        begin = mid + 1;
                    }
                }else if(nums[begin] > nums[mid]){
                    end = mid -1;
                }else if(nums[begin] == nums[mid]){
                    begin = mid + 1;
                }
            }else if(target > nums[mid]){
                if(nums[begin] < nums[mid]){
                    begin = mid + 1;
                }else if(nums[begin] > nums[mid]){
                    if(target >=nums[begin]){
                       end = mid -1; 
                    }else{
                        begin = mid +1;
                    }
                }else if(nums[begin] == nums[mid])
                    begin = mid + 1;
            }
        }
        return false;        
    }
};

82. 删除排序链表中的重复元素 II

给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

示例 1:

输入: 1->2->3->3->4->4->5
输出: 1->2->5

示例 2:

输入: 1->1->1->2->3
输出: 2->3

/**
 * 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 == NULL) return head;
        double tmp=1.2;
        ListNode* dummy = new ListNode(0);
        ListNode* s=dummy;
        while(head!=NULL && head->next!=NULL){
            if(head->val == head->next->val) tmp=head->val;
            if(head->val!=tmp){
                ListNode* tp = new ListNode(head->val);
                s->next=tp;
                s=s->next;
            }
            head=head->next;
        }
        if(head->val != tmp){
            ListNode* tp = new ListNode(head->val);
            s->next=tp;
            s=s->next;
        }
        return dummy->next;
    }
};

83. 删除排序链表中的重复元素

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例 1:

输入: 1->1->2
输出: 1->2

示例 2:

输入: 1->1->2->3->3
输出: 1->2->3

/**
 * 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 == NULL) return head;
        ListNode* resHead = head;
        while(head->next != NULL){
            if(head->val == head->next->val) {
                head->next = head->next->next;
            } else head=head->next;
        }
        return resHead;
    }
};

84. 柱状图中最大的矩形

给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。

求在该柱状图中，能够勾勒出来的矩形的最大面积。

 

以上是柱状图的示例，其中每个柱子的宽度为 1，给定的高度为 [2,1,5,6,2,3]。

 

图中阴影部分为所能勾勒出的最大矩形面积，其面积为 10 个单位。

 

示例:

输入: [2,1,5,6,2,3]
输出: 10

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        heights.push_back(-1);
        int max_size=0;
        int index=0;
        stack<int> s;
 
        while(index<heights.size()){
            if(s.size()==0||heights[s.top()]<=heights[index]){
                s.push(index);
                index++;
            } else {
                int top=s.top();
                s.pop();
                int size=0; 
                if(s.size()==0) {
                    size=heights[top]*index;
                } else {
                    size=heights[top]*(index-s.top()-1);
                } 
                if(size>max_size) max_size=size;
            }
        } 
        return max_size;
    }
};

85. 最大矩形

给定一个仅包含 0 和 1 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

示例:

输入:
[
  ["1","0","1","0","0"],
  ["1","0","1","1","1"],
  ["1","1","1","1","1"],
  ["1","0","0","1","0"]
]
输出: 6

class Solution {
public:
    int maximalRectangle(vector<vector<char> > &matrix) {  
        if(matrix.size()==0) return 0;     
        int* hist = new int[matrix[0].size()];  
        memset(hist, 0, sizeof(int)*matrix[0].size());    
        int max_ = 0;    
        for(int i=0; i<matrix.size(); i++){  
            for(int j=0; j<matrix[0].size(); j++){  
                if(matrix[i][j]=='1')  *(hist+j) += 1;  
                else  *(hist+j) = 0;  
            }    
            max_ = max(max_, maxRectInHistogram(hist, matrix[0].size()) );  
        }     
        return max_;  
    }   
    int maxRectInHistogram(int hist[], int n){      
        int max_ = hist[0]; 
        int j = 0, k = 0, temp =0;
        for(int i=0; i<n; i++){    
                j = i, k = i;
                while(j < n&&hist[j] >= hist[i])j++;
                while(k >= 0&&hist[k] >=hist[i])k--;
                temp = (j-k-2 + 1)*hist[i];
                max_ = max(temp,max_);
        }      
        return max_;    
    }    
};

(以上题目均摘自leetcode)