rewrite

Author: mengli

LargestRectangleinHistogram.java

@@ -1,4 +1,5 @@
-
+import java.util.Arrays;
+import java.util.Stack;
 
 /**
  * Given n non-negative integers representing the histogram's bar height where
@@ -14,35 +15,20 @@
  */
 
 public class LargestRectangleinHistogram {
-	// O(n) using two stacks
 	public int largestRectangleArea(int[] height) {
-		int area = 0;
-		java.util.Stack<Integer> heightStack = new java.util.Stack<Integer>();
-		java.util.Stack<Integer> indexStack = new java.util.Stack<Integer>();
-		for (int i = 0; i < height.length; i++) {
-			if (heightStack.empty() || heightStack.peek() <= height[i]) {
-				heightStack.push(height[i]);
-				indexStack.push(i);
-			} else if (heightStack.peek() > height[i]) {
-				int j = 0;
-				while (!heightStack.empty() && heightStack.peek() > height[i]) {
-					j = indexStack.pop();
-					int currArea = (i - j) * heightStack.pop();
-					if (currArea > area) {
-						area = currArea;
-					}
-				}
-				heightStack.push(height[i]);
-				indexStack.push(j);
-			}
-		}
-		while (!heightStack.empty()) {
-			int currArea = (height.length - indexStack.pop())
-					* heightStack.pop();
-			if (currArea > area) {
-				area = currArea;
+		Stack<Integer> stack = new Stack<Integer>();
+		int i = 0;
+		int maxArea = 0;
+		int[] h = new int[height.length + 1];
+		h = Arrays.copyOf(height, height.length + 1);
+		while (i < h.length) {
+			if (stack.isEmpty() || h[stack.peek()] <= h[i]) {
+				stack.push(i++);
+			} else {
+				int t = stack.pop();
+				maxArea = Math.max(maxArea, h[t] * (stack.isEmpty() ? i : i - stack.peek() - 1));
 			}
 		}
-		return area;
+		return maxArea;
 	}
 }

MaximalRectangle.java

@@ -1,59 +1,42 @@
-
-
 /**
  * Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle
  * containing all ones and return its area.
  */
 
 public class MaximalRectangle {
 	public int maximalRectangle(char[][] matrix) {
-		int row = matrix.length;
-		if (row == 0)
+		int rows = matrix.length;
+		if (rows == 0)
 			return 0;
-		int col = matrix[0].length;
-		int[][] map = new int[row][col];
-		int area = 0;
-		for (int i = 0; i < row; i++) {
-			for (int j = 0; j < col; j++) {
-				int prev = 0;
-				if (i != 0) {
-					prev = map[i - 1][j];
-				}
-				if (matrix[i][j] == '1') {
-					map[i][j] = prev + 1;
-				} else {
-					map[i][j] = prev;
-				}
+		int maxArea = 0;
+		int cols = matrix[0].length;
+		int[][] map = new int[rows][cols];
+		for (int j = 0; j < cols; j++) {
+			map[0][j] = matrix[0][j] == '0' ? 0 : 1;
+		}
+		for (int i = 1; i < rows; i++) {
+			for (int j = 0; j < cols; j++) {
+				map[i][j] = matrix[i][j] == '0' ? map[i - 1][j]
+						: map[i - 1][j] + 1;
 			}
 		}
-		for (int i = 0; i < row; i++) {
-			for (int j = i; j < row; j++) {
-				int[] line = new int[col];
-				for (int k = 0; k < col; k++) {
-					line[k] = map[j][k] - map[i][k]
-							+ (matrix[i][k] == '0' ? 0 : 1);
+		int[] row = new int[cols];
+		for (int i = 0; i < rows; i++) {
+			for (int j = i; j < rows; j++) {
+				for (int k = 0; k < cols; k++) {
+					row[k] = map[j][k] - (i == 0 ? 0 : map[i - 1][k]);
 				}
-				int l = 0;
-				int tmp = 0;
-				for (int f = 0; f < col; f++) {
-					if (line[f] == j - i + 1)
-						tmp++;
-					else {
-						if (tmp > l) {
-							l = tmp;
-						}
-						tmp = 0;
+				int count = 0;
+				for (int k = 0; k < cols; k++) {
+					if (row[k] == j - i + 1) {
+						maxArea = Math.max(maxArea, ++count * (j - i + 1));
+					} else {
+						maxArea = Math.max(maxArea, count * (j - i + 1));
+						count = 0;
 					}
 				}
-				if (tmp > l) {
-					l = tmp;
-				}
-				int s = (j - i + 1) * l;
-				if (s > area) {
-					area = s;
-				}
 			}
 		}
-		return area;
+		return maxArea;
 	}
 }