int maximalRectangle(vector<vector<bool> > &matrix)
{
int n=matrix.size();
if(n==0)
return 0;
int m=matrix[0].size();
int result=0;
vector<int> height(m,0);
for(int j=0;j<m;++j)
{
height[j]=matrix[0][j];
result=max(result,largestRectangleArea(height));
}
for(int i=1;i<n;++i)
{
for(int j=0;j<m;++j)
{
if(matrix[i][j]==0)
height[j]=0;
else
++height[j];
}
result=max(result,largestRectangleArea(height));
}
return result;
}
int maximalRectangle(vector<vector<char> >& matrix) {
// 理解错题了，不是求一个矩阵，里面包含了原矩阵所有的1
// 而是求以 1 组合的矩阵，最大的那个的 area
//
// 然后是一种解法超时，这种解法的是这样的生成一个 dp[m][n]
// 值是当前这一行，以m n 结尾，有多少个连续的 1 了，如果matrix[m][n]==0,dp[m][n]=0
// 整个扫完之后，再扫，这次是扫 dp，如果 dp[m][n]不是1，往上往下扫，如果同一列还是大于等于它，说明是矩形算高度，求面积
// 这种算法的问题是大数据超时
//
// 怎么办？用Largest Rectangle in Histogram 求解。
// Largest Rectangle in Histogram 是求一个 non negative arrary 的最大面积，这样想：
// 生成一个长度是 martrix[0].size() 的 array，每一个value就是这一往上数连续的列的1的个数。
// 一秒变老题目
if (matrix.empty()) return 0;
vector<int> thisRowHeight(matrix[0].size(), 0);
int max_value = 0;
for (int i = 0; i < matrix.size(); i++) {
for (int j = 0; j < matrix[0].size(); j++) {
if (matrix[i][j] == '1') {
thisRowHeight[j] = thisRowHeight[j] + 1;
} else {
thisRowHeight[j] = 0;
}
}
// 这里第一次想半天，写到 for j 里面去了，败笔
max_value = max(max_value, largestRectangleArea(thisRowHeight));
}
return max_value;
}
int maximalRectangle(vector<vector<char> > &matrix) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (!matrix.size() || !matrix[0].size()){
return 0;
}
int len1 = matrix.size(), len2 = matrix[0].size();
int result = 0, tmp = 0;
vector<vector<int> > sum(len1);
for (int i = 0; i != len1; i++){
sum[i].resize(len2);
for (int j = 0; j != len2; j++){
if (matrix[i][j] == '0')
sum[i][j] = 0;
else if (!i)
sum[i][j] = 1;
else
sum[i][j] = sum[i-1][j] + 1;
}
tmp = largestRectangleArea(sum[i]);
result = max(result, tmp);
}
return result;
}
int maximalRectangle(vector<vector<char> > &matrix) {
int H = matrix.size(), W = H ? matrix[0].size() : 0;
if (H == 0) return 0;
int max_rect = 0;
vector<int> hist(W, 0);
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
hist[j] = matrix[i][j] == '1' ? hist[j] + 1 : 0;
}
max_rect = max(max_rect, largestRectangleArea(hist));
}
return max_rect;
}
int maximalRectangle(vector<vector<char>>& matrix) {
int ret = 0;
int row = matrix.size();
if (row == 0) return ret;
int col = matrix[0].size();
if (col == 0) return ret;
vector<int> dp(col);
for (int i=0; i<row; i++) {
for (int j=0; j<col; j++) {
dp[j] = matrix[i][j] == '1' ? dp[j] + 1 : 0;
}
ret = max(ret, largestRectangleArea(dp));
}
return ret;
}
int maximalRectangle(char** matrix, int matrixRowSize, int matrixColSize) {
int maxArea = 0;
if (matrixRowSize == 0 || matrixColSize == 0) return 0;
int* height = (int*) malloc(matrixColSize * sizeof(int));
memset(height, 0, matrixColSize * sizeof(int));
for (int i = 0; i < matrixRowSize; i++) {
for (int j = 0; j < matrixColSize; j++) {
if (matrix[i][j] == '1') {
height[j]++;
} else if (matrix[i][j] == '0') {
height[j] = 0;
}
}
int area = largestRectangleArea(height, matrixColSize);
if (maxArea < area) maxArea = area;
}
return maxArea;
}
int maximalRectangle(vector<vector<char>>& matrix) {
if(matrix.empty()||matrix[0].empty())
return 0;
int m=matrix.size(),n=matrix[0].size();
int area=0;
vector<int>height(n,0);//初始化
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(matrix[i][j]=='0')
height[j]=0;
else
height[j]++;
}
int tmp=largestRectangleArea(height);
area=max(area,tmp);
}
return area;
}
int maximalRectangle(char **matrix, int matrixRowSize, int matrixColSize)
{
int h[matrixColSize];
int i, j, max, t;
max = 0;
memset(h, 0, sizeof(h));
for (i = 0; i < matrixRowSize; i++) {
for (j = 0; j < matrixColSize; j++)
if (matrix[i][j] == '1')
h[j]++;
else
h[j] = 0;
t = largestRectangleArea(h, matrixColSize);
if (t > max)
max = t;
}
return(max);
}
int maximalRectangle(vector<vector<char> > &matrix) {
if (matrix.size()<=0 || matrix[0].size()<=0) return 0;
int row = matrix.size();
int col = matrix[0].size();
vector< vector<int> > heights(row, vector<int>(col));
int maxArea = 0;
for(int i=0; i<row; i++){
for(int j=0; j<col; j++) {
if (matrix[i][j]=='1'){
heights[i][j] = (i==0 ? 1 : heights[i-1][j] + 1);
}
}
int area = largestRectangleArea(heights[i]);
if (area > maxArea) maxArea = area;
}
return maxArea;
}
// Time: O(n^2)
// Space: O(n)
int maximalRectangle(vector<vector<char> > &matrix) {
int m = matrix.size();
if (m == 0) {
return 0;
}
int n = matrix[0].size();
vector<int> height(n, 0);
int maxRect = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (matrix[i][j] == '0') {
height[j] = 0;
} else {
height[j]++;
}
}
maxRect = max(maxRect, largestRectangleArea(height));
}
return maxRect;
}
int maximalRectangle(vector<vector<char>>& matrix) {
if(matrix.empty() || matrix[0].empty() )
return 0;
int m=matrix.size();
int n=matrix[0].size();
int res=0;
vector<int> first(n,0);
for(int i=0; i<m; i++)
{
for(int j=0; j<n; j++)
{
if(matrix[i][j]=='1')
first[j]++;
else
first[j]=0;
}
res=max(res,largestRectangleArea(first));
}
return res;
}
int maximalRectangle(char** matrix, int matrixRowSize, int matrixColSize) {
int *heights;
int i, j;
int line_result;
int max = 0;
heights = (int*)malloc(matrixColSize * sizeof(int));
for (i = 0; i < matrixColSize; i++) {
heights[i] = 0;
}
for (i = 0; i < matrixRowSize; i++) {
for (j = 0; j < matrixColSize; j++) {
if ('0' == matrix[i][j]) {
heights[j] = 0;
} else {
heights[j] += 1;
}
}
line_result = largestRectangleArea(heights, matrixColSize);
if (line_result > max) {
max = line_result;
}
}
return max;
}
