Format

Author: mengli

3sum.java

@@ -4,11 +4,12 @@
 
 Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ? b ? c)
 The solution set must not contain duplicate triplets.
-    For example, given array S = {-1 0 1 2 -1 -4},
 
-    A solution set is:
-    (-1, 0, 1)
-    (-1, -1, 2)
+For example, given array S = {-1 0 1 2 -1 -4},
+
+A solution set is:
+(-1, 0, 1)
+(-1, -1, 2)
 
 public class Solution {
     public ArrayList<ArrayList<Integer>> threeSum(int[] num) {

4Sum.java

@@ -4,12 +4,13 @@
 
 Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ? b ? c ? d)
 The solution set must not contain duplicate quadruplets.
-    For example, given array S = {1 0 -1 0 -2 2}, and target = 0.
 
-    A solution set is:
-    (-1,  0, 0, 1)
-    (-2, -1, 1, 2)
-    (-2,  0, 0, 2)
+For example, given array S = {1 0 -1 0 -2 2}, and target = 0.
+
+A solution set is:
+(-1,  0, 0, 1)
+(-2, -1, 1, 2)
+(-2,  0, 0, 2)
 
 public class Solution {
     public ArrayList<ArrayList<Integer>> fourSum(int[] num, int target) {

Add Binary.java

@@ -8,36 +8,36 @@ Given two binary strings, return their sum (also a binary string).
 public class Solution {
     public String addBinary(String a, String b) {
     	int i = a.length() - 1;
-		int j = b.length() - 1;
-		int da = 0;
-		int db = 0;
-		int adv = 0;
-		StringBuffer result = new StringBuffer();
-		while (i >= 0 && j >= 0) {
-			da = a.charAt(i--) == '0' ? 0 : 1;
-			db = b.charAt(j--) == '0' ? 0 : 1;
-			int d = da + db + adv;
-			result.append(d % 2 == 0 ? '0' : '1');
-			adv = d >> 1;
-		}
-		if (i >= 0) {
-			while (i >= 0) {
-				da = a.charAt(i--) == '0' ? 0 : 1;
-				int d = da + adv;
-				result.append(d % 2 == 0 ? '0' : '1');
-				adv = d >> 1;
-			}
-		} else if (j >= 0) {
-			while (j >= 0) {
-				db = b.charAt(j--) == '0' ? 0 : 1;
-				int d = db + adv;
-				result.append(d % 2 == 0 ? '0' : '1');
-				adv = d >> 1;
-			}
-		}
-		if (adv == 1) {
-			result.append('1');
-		}
-		return result.reverse().toString();
+	int j = b.length() - 1;
+	int da = 0;
+	int db = 0;
+	int adv = 0;
+	StringBuffer result = new StringBuffer();
+	while (i >= 0 && j >= 0) {
+	    da = a.charAt(i--) == '0' ? 0 : 1;
+	    db = b.charAt(j--) == '0' ? 0 : 1;
+	    int d = da + db + adv;
+	    result.append(d % 2 == 0 ? '0' : '1');
+	    adv = d >> 1;
 	}
+	if (i >= 0) {
+	    while (i >= 0) {
+		da = a.charAt(i--) == '0' ? 0 : 1;
+		int d = da + adv;
+		result.append(d % 2 == 0 ? '0' : '1');
+		adv = d >> 1;
+	    }
+	} else if (j >= 0) {
+	    while (j >= 0) {
+		db = b.charAt(j--) == '0' ? 0 : 1;
+		int d = db + adv;
+		result.append(d % 2 == 0 ? '0' : '1');
+		adv = d >> 1;
+	    }
+	}
+	if (adv == 1) {
+	    result.append('1');
+	}
+	return result.reverse().toString();
+    }
 }

Anagrams.java

@@ -5,33 +5,33 @@
 public class Solution {
     public ArrayList<String> anagrams(String[] strs) {
     	ArrayList<String> ret = new ArrayList<String>();
-		ArrayList<String> ar = new ArrayList<String>();
-		for (String s : strs) {
-			char[] c = s.toCharArray();
-			Arrays.sort(c);
-			ar.add(new String(c));
+	ArrayList<String> ar = new ArrayList<String>();
+	for (String s : strs) {
+	    char[] c = s.toCharArray();
+	    Arrays.sort(c);
+	    ar.add(new String(c));
+	}
+	int[] list = new int[strs.length];
+	int tmp = 0;
+	for (int i = 0; i < ar.size(); i++) {
+	    if (list[i] == 0) {
+	        list[i] = 1;
+		tmp = 1;
+		for (int j = i + 1; j < ar.size(); j++) {
+		    if (list[j] == 0 && ar.get(i).equals(ar.get(j))) {
+			list[j] = 1;
+			tmp++;
+		    }
 		}
-		int[] list = new int[strs.length];
-		int tmp = 0;
-		for (int i = 0; i < ar.size(); i++) {
-			if (list[i] == 0) {
-				list[i] = 1;
-				tmp = 1;
-				for (int j = i + 1; j < ar.size(); j++) {
-					if (list[j] == 0 && ar.get(i).equals(ar.get(j))) {
-						list[j] = 1;
-						tmp++;
-					}
-				}
-				if (tmp == 1) {
-					list[i] = 0;
-				}
-			}
+		if (tmp == 1) {
+		    list[i] = 0;
 		}
-		for (int i = 0; i < list.length; i++) {
-			if (list[i] == 1)
-				ret.add(strs[i]);
-		}
-		return ret;
+	    }
+	}
+	for (int i = 0; i < list.length; i++) {
+	    if (list[i] == 1)
+		ret.add(strs[i]);
+	}
+        return ret;
     }
 }

Balanced Binary Tree.java

@@ -15,16 +15,16 @@
 public class Solution {
     public boolean isBalanced(TreeNode root) {
     	return determine(root) >= 0 ? true : false;
-	}
+    }
 
-	public int determine(TreeNode root) {
-		if (root == null) {
-			return 0;
-		} else {
-			int leftDepth = determine(root.left);
-			int rightDepth = determine(root.right);
-			if (leftDepth < 0 || rightDepth < 0 || Math.abs(leftDepth - rightDepth) > 1) return -1;
-			return Math.max(leftDepth, rightDepth) + 1;
-		}
+    public int determine(TreeNode root) {
+	if (root == null) {
+	    return 0;
+	} else {
+	    int leftDepth = determine(root.left);
+	    int rightDepth = determine(root.right);
+	    if (leftDepth < 0 || rightDepth < 0 || Math.abs(leftDepth - rightDepth) > 1) return -1;
+	    return Math.max(leftDepth, rightDepth) + 1;
 	}
+    }
 }

Best Time to Buy and Sell Stock III.java

@@ -6,16 +6,16 @@
 You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
 
 public class Solution {
-	public int maxProfit(int[] prices) {
-		if (prices.length < 2) return 0;
-		int max = 0;
-		for (int i = 0; i < prices.length; i++) {
-			max = Math.max(max, maxProfitSingle(prices, 0, i) + maxProfitSingle(prices, i, prices.length - 1));
-		}
-		return max;
+    public int maxProfit(int[] prices) {
+	if (prices.length < 2) return 0;
+	    int max = 0;
+	    for (int i = 0; i < prices.length; i++) {
+		max = Math.max(max, maxProfitSingle(prices, 0, i) + maxProfitSingle(prices, i, prices.length - 1));
+	    }
+	    return max;
 	}
 
-	public int maxProfitSingle(int[] prices, int start, int end) {
+    public int maxProfitSingle(int[] prices, int start, int end) {
         int lowest = 0;
         int maxProfit = 0;
         if (end - start + 1 > 0) {

Binary Tree Inorder Traversal.java

@@ -28,17 +28,17 @@ public ArrayList<Integer> inorderTraversal(TreeNode root) {
         s.add(root);
         TreeNode p = root.left;
         while (!s.empty()) {
-        	while (p != null) {
-        		s.add(p);
-        		p = p.left;
-        	}
-        	TreeNode n = s.pop();
-        	inOrder.add(n.val);
-        	p = n.right;
-        	if (p != null) {
-        		s.add(p);
-        		p = p.left;
-        	}
+            while (p != null) {
+        	s.add(p);
+        	p = p.left;
+            }
+            TreeNode n = s.pop();
+            inOrder.add(n.val);
+            p = n.right;
+            if (p != null) {
+        	s.add(p);
+        	p = p.left;
+            }
         }
         return inOrder;
     }

Binary Tree Level Order Traversal II.java

@@ -35,27 +35,27 @@ public ArrayList<ArrayList<Integer>> levelOrderBottom(TreeNode root) {
     	ArrayList<Integer> level = new ArrayList<Integer>();
     	q.add(root);
     	while(!q.isEmpty()) {
-    		TreeNode n = q.poll();
-    		curr--;
-    		level.add(n.val);
-    		if (n.left != null) {
-    			q.add(n.left);
-    			next++;
-    		}
-    		if (n.right != null) {
-    			q.add(n.right);
-    			next++;
-    		}
-    		if (curr == 0) {
-    			levels.add(level);
-    			level = new ArrayList<Integer>();
-    			curr = next;
-    			next = 0;
-    		}
+    	    TreeNode n = q.poll();
+    	    curr--;
+    	    level.add(n.val);
+    	    if (n.left != null) {
+    		q.add(n.left);
+    		next++;
+    	    }
+    	    if (n.right != null) {
+    		q.add(n.right);
+    		next++;
+    	    }
+    	    if (curr == 0) {
+    		levels.add(level);
+    		level = new ArrayList<Integer>();
+    		curr = next;
+    		next = 0;
+    	    }
     	}
     	ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
     	for (int i = levels.size() - 1; i >= 0; i--) {
-    		result.add(levels.get(i));
+    	    result.add(levels.get(i));
     	}
     	return result;
     }

Binary Tree Maximum Path Sum.java

@@ -12,38 +12,38 @@
 
 public class Solution {
 
-	public class MyInt {
+    public class MyInt {
 
-		private int value;
+	private int value;
 
-		public int getValue() {
-			return value;
-		}
-
-		public void setValue(int value) {
-			this.value = value;
-		}
+	public int getValue() {
+	    return value;
+	}
 
-		public MyInt(int value) {
-			this.value = value;
-		}
+	public void setValue(int value) {
+	    this.value = value;
+	}
 
+	public MyInt(int value) {
+	    this.value = value;
 	}
+
+    }
 
-	public int maxPathSum(TreeNode root) {
-		MyInt maxSum = new MyInt(Integer.MIN_VALUE);
-		findMaxSum(root, maxSum);
-		return maxSum.getValue();
-	}
+    public int maxPathSum(TreeNode root) {
+	MyInt maxSum = new MyInt(Integer.MIN_VALUE);
+	findMaxSum(root, maxSum);
+	return maxSum.getValue();
+    }
 
-	public int findMaxSum(TreeNode root, MyInt maxSum) {
+    public int findMaxSum(TreeNode root, MyInt maxSum) {
     	if (root == null)
-			return 0;
-		int cpath = 0;
-		int left = findMaxSum(root.left, maxSum);
-		int right = findMaxSum(root.right, maxSum);
-		cpath = Math.max(root.val, Math.max(root.val + left, root.val + right));
-		maxSum.setValue(Math.max(maxSum.getValue(), Math.max(root.val + left + right, cpath)));
-		return cpath;
-	}
+	    return 0;
+	int cpath = 0;
+	int left = findMaxSum(root.left, maxSum);
+	int right = findMaxSum(root.right, maxSum);
+	cpath = Math.max(root.val, Math.max(root.val + left, root.val + right));
+	maxSum.setValue(Math.max(maxSum.getValue(), Math.max(root.val + left + right, cpath)));
+	return cpath;
+    }
 }

Climbing Stairs.java

@@ -2,12 +2,12 @@
 
 Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?
 
-    public int climbStairs(int n) {
-		int[] arr = new int[n + 1];
-        arr[0] = 1;
-        arr[1] = 1;
-        for (int i = 2; i <= n; i++) {
-        	arr[i] = arr[i - 1] + arr[i - 2];
-        }
-        return arr[n];
-    }
+public int climbStairs(int n) {
+    int[] arr = new int[n + 1];
+    arr[0] = 1;
+    arr[1] = 1;
+    for (int i = 2; i <= n; i++) {
+        arr[i] = arr[i - 1] + arr[i - 2];
+    }
+    return arr[n];
+}