leetcode 最大矩形和

1.枚举法（超时）

 1 public class Solution {
 2     public int largestRectangleArea(int[] height) {
 3         int max=-1;
 4         for(int i=0;i<height.length;i++)
 5         {
 6             int len=1;
 7             int k=i-1;
 8             while(k>=0&&height[k]<=height[i])
 9             {
10                 k--;
11                 len++;
12             }
13             k=i+1;
14             while(k<height.length&&height[k]<=height[i])  
15             {
16                 len++;
17                 k++;
18                 
19                 
20                 
21             }
22             if(max<len)
23             {
24                 max=len;
25             }
26             
27             
28                 
29             }
30             return max;
31         
32             
33             
34             
35        
36         
37     }
38 }

View Code

2.单调栈(AC)，其实模拟了第一种方法，nyoj做过，效率为线性。写的代码有点长，但是很好理解

 1 class node
 2 {
 3     int d; //di 
 4     int h;// higtht
 5 }
 6     
 7 
 8 
 9 public class Solution {
10     public int largestRectangleArea(int[] height) {
11         int len=height.length;
12         if(len==0) return 0;
13         node n[]=new node[len];
14         for(int i=0;i<len;i++)
15         {
16             n[i]=new node();
17             n[i].d=1;
18             n[i].h=height[i];
19             
20         }
21         Stack<node> s=new Stack<node>();
22         s.push(n[0]);
23         int max=n[0].h;
24         for(int j=1;j<len;j++)
25         {
26             node t=s.peek();
27             if(n[j].h>=t.h)
28             {
29                 s.push(n[j]);
30             }
31             else
32             {
33                 int with=0;
34                 while(!s.isEmpty()&&s.peek().h>n[j].h)
35                 {  
36                    t=s.pop();
37                     with+=t.d;
38                     if(with*t.h>max) max=with*t.h;
39                     
40                 }
41                 n[j].d+=with;
42                 s.push(n[j]);
43                     
44              }
45             
46                 
47                 
48         }
49         int with=0;
50         while(!s.isEmpty())
51         {
52             node t=s.pop();
53             with=with+t.d;
54             int temp=t.h*with;
55             
56             if(temp>max) max=temp;
57              
58         }
59             
60 return max;
61     }}

View Code

3.最大01矩阵()。使用上述四项，枚举每一行。

 1 class node
 2 {
 3     int d; //di 
 4     int h;// higtht
 5 }
 6     
 7 public class Solution {
 8     public int largest(int[] height) {
 9         int len=height.length;
10         if(len==0) return 0;
11         node n[]=new node[len];
12         for(int i=0;i<len;i++)
13         {
14             n[i]=new node();
15             n[i].d=1;
16             n[i].h=height[i];
17             
18         }
19         Stack<node> s=new Stack<node>();
20         s.push(n[0]);
21         int max=n[0].h;
22         for(int j=1;j<len;j++)
23         {
24             node t=s.peek();
25             if(n[j].h>=t.h)
26             {
27                 s.push(n[j]);
28             }
29             else
30             {
31                 int with=0;
32                 while(!s.isEmpty()&&s.peek().h>n[j].h)
33                 {  
34                    t=s.pop();
35                     with+=t.d;
36                     if(with*t.h>max) max=with*t.h;
37                     
38                 }
39                 n[j].d+=with;
40                 s.push(n[j]);
41                     
42              }
43             
44                 
45                 
46         }
47         int with=0;
48         while(!s.isEmpty())
49         {
50             node t=s.pop();
51             with=with+t.d;
52             int temp=t.h*with;
53             
54             if(temp>max) max=temp;
55              
56         }
57             
58 return max;
59     }
60     public int maximalRectangle(char[][] matrix) {
61         if(matrix.length==0) return 0;
62         
63        int len=matrix[0].length;
64        int ans[]=new int[len];
65        for(int i=0;i<len;i++)
66        {
67            ans[i]=matrix[0][i]-'0';
68        }
69        int max=largest(ans);
70         
71         for(int i=1;i<matrix.length;i++)
72         {
73            for(int j=0;j<matrix[0].length;j++)
74            {
75                if(matrix[i][j]=='0') ans[j]=0;
76                
77                else 
78                {
79                    ans[j]+=1;
80                }
81               
82               
83                
84            }
85           
86           int t=largest(ans);
87           if(max<t) max=t;
88             
89             
90         }
91         
92         
93         
94         
95         return max;
96         
97     }
98 }

View Code

https://oj.leetcode.com/problems/maximal-rectangle/

 

转载于:https://www.cnblogs.com/hansongjiang/p/3840072.html