Write some code.

Author: mengli

Interleaving String.java

@@ -23,4 +23,51 @@ public boolean isInterleave(String s1, String s2, String s3) {
 				mat[i][j] = (mat[i][j - 1] && s2.charAt(j - 1) == s3.charAt(i + j - 1)) || (mat[i - 1][j] && s1.charAt(i - 1) == s3.charAt(i + j - 1));
 		return mat[s1.length()][s2.length()];
 	}
+}
+
+
+
+
+
+
+
+
+
+
+
+public class Solution {
+    public boolean isInterleave(String s1, String s2, String s3) {
+    	return search(s1, s2, s3, 0, 0, 0);
+	}
+
+	private boolean search(String s1, String s2, String s3, int i1, int i2, int i3) {
+		int len1 = s1.length(), len2 = s2.length();
+		if (i1 < len1 && i2 < len2) {
+			boolean result = false;
+			if (s1.charAt(i1) == s3.charAt(i3)) {
+				i1++;
+				i3++;
+				result = search(s1, s2, s3, i1, i2, i3);
+				if (result) {
+					return true;
+				} else {
+					i1--;
+					i3--;
+				}
+			}
+			
+			if (s2.charAt(i2) == s3.charAt(i3)) {
+				i2++;
+				i3++;
+				result = search(s1, s2, s3, i1, i2, i3);
+				return result;
+			}
+			
+			return false;
+		}
+		if (i1 < len1) {
+			return s1.substring(i1).compareTo(s3.substring(i3)) == 0;
+		}
+		return s2.substring(i2).compareTo(s3.substring(i3)) == 0;
+	}
 }

Maximal Rectangle.java

@@ -0,0 +1,51 @@
+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 Solution {
+    public int maximalRectangle(char[][] matrix) {
+        int row = matrix.length;
+        if (row == 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;
+                }
+            }
+        }
+        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 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;
+                    }
+                }
+                if (tmp > l) {
+                    l = tmp;
+                }
+                int s = (j - i + 1) * l;
+                if (s > area) {
+                    area = s; 
+                }
+            }
+        }
+        return area;
+    }
+}

Scramble String.java

@@ -0,0 +1,73 @@
+Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively.
+
+Below is one possible representation of s1 = "great":
+
+    great
+   /    \
+  gr    eat
+ / \    /  \
+g   r  e   at
+           / \
+          a   t
+To scramble the string, we may choose any non-leaf node and swap its two children.
+
+For example, if we choose the node "gr" and swap its two children, it produces a scrambled string "rgeat".
+
+    rgeat
+   /    \
+  rg    eat
+ / \    /  \
+r   g  e   at
+           / \
+          a   t
+We say that "rgeat" is a scrambled string of "great".
+
+Similarly, if we continue to swap the children of nodes "eat" and "at", it produces a scrambled string "rgtae".
+
+    rgtae
+   /    \
+  rg    tae
+ / \    /  \
+r   g  ta  e
+       / \
+      t   a
+We say that "rgtae" is a scrambled string of "great".
+
+Given two strings s1 and s2 of the same length, determine if s2 is a scrambled string of s1.
+
+public class Solution {
+    public boolean isScramble(String s1, String s2) {
+    	int length1 = s1.length();
+		int length2 = s2.length();
+		if (length1 != length2)
+			return false;
+
+		if (length1 == 0 || s1.equals(s2))
+			return true;
+
+		char[] ca1 = s1.toCharArray();
+		char[] ca2 = s2.toCharArray();
+		Arrays.sort(ca1);
+		Arrays.sort(ca2);
+		if (!Arrays.equals(ca1, ca2))
+			return false;
+
+		int i = 1;
+		while (i < length1) {
+			String a1 = s1.substring(0, i);
+			String b1 = s1.substring(i, length1);
+			String a2 = s2.substring(0, i);
+			String b2 = s2.substring(i, length2);
+			if (a1.equals(b2) && b1.equals(a2)) return true;
+			boolean r = isScramble(a1, a2) && isScramble(b1, b2);
+			if (!r) {
+				String c2 = s2.substring(0, length1 - i);
+				String d2 = s2.substring(length1 - i);
+				r = isScramble(a1, d2) && isScramble(b1, c2);
+			}
+			if (r) return true;
+			i++;
+		}
+		return false;
+	}
+}

Set Matrix Zeroes.java

@@ -0,0 +1,36 @@
+Given a m x n matrix, if an element is 0, set its entire row and column to 0. Do it in place.
+
+Follow up:
+Did you use extra space?
+A straight forward solution using O(mn) space is probably a bad idea.
+A simple improvement uses O(m + n) space, but still not the best solution.
+Could you devise a constant space solution?
+
+public class Solution {
+    public void setZeroes(int[][] matrix) {
+        int row = matrix.length;
+        if (row == 0) return;
+        int col = matrix[0].length;
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (matrix[i][j] == 0) {
+                    for (int k = 0; k < col; k++) {
+                        if (matrix[i][k] != 0)
+                            matrix[i][k] = -1;
+                    }
+                    for (int f = 0; f < row; f++) {
+                        if (matrix[f][j] != 0)
+                            matrix[f][j] = -1;
+                    }
+                }
+            }
+        }
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (matrix[i][j] == -1) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+    }
+}

Unique Binary Search Trees.java

@@ -0,0 +1,29 @@
+Given n, how many structurally unique BST's (binary search trees) that store values 1...n?
+
+For example,
+Given n = 3, there are a total of 5 unique BST's.
+
+   1         3     3      2      1
+    \       /     /      / \      \
+     3     2     1      1   3      2
+    /     /       \                 \
+   2     1         2                 3
+
+public class Solution {
+    public int numTrees(int n) {
+        if (n == 1) return 1;
+        if (n == 2) return 2;
+    	int[] record = new int[n + 1];
+		record[0] = 1;
+        record[1] = 1;
+        record[2] = 2;
+        for (int i = 3; i <= n; i++) {
+        	int tmp = 0;
+        	for (int k = 0; k < i; k++) {
+        		tmp += (record[k] * record[i - k - 1]);
+        	}
+        	record[i] = tmp;
+        }
+        return record[n];
+    }
+}