Add

Author: mengli

JumpGameII.java

@@ -0,0 +1,30 @@
+/**
+ * 
+ * Given an array of non-negative integers, you are initially positioned at the first index of the array.
+ * 
+ * Each element in the array represents your maximum jump length at that position.
+ * 
+ * Your goal is to reach the last index in the minimum number of jumps.
+ * 
+ * For example:
+ * 
+ * Given array A = [2,3,1,1,4]
+ * 
+ * The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)
+ */
+
+public class JumpGameII {
+	public int jump(int[] A) {
+		int ret = 0;
+		int last = 0;
+		int curr = 0;
+		for (int i = 0; i < A.length; ++i) {
+			if (i > last) {
+				last = curr;
+				++ret;
+			}
+			curr = Math.max(curr, i + A[i]);
+		}
+		return ret;
+	}
+}

NQueensII.java

@@ -0,0 +1,54 @@
+/**
+ * Follow up for N-Queens problem.
+ * 
+ * Now, instead outputting board configurations, return the total number of distinct solutions.
+ *
+ */
+
+public class NQueensII {
+	public int solveNQueens(int n) {
+		if (n == 0)
+			return 0;
+		StringBuffer line = new StringBuffer();
+		for (int i = 0; i < n; i++) {
+			line.append('.');
+		}
+		StringBuffer[] sol = new StringBuffer[n];
+		for (int i = 0; i < n; i++) {
+			sol[i] = new StringBuffer(line.toString());
+		}
+		boolean[] cols = new boolean[n];
+		int[] row = new int[n];
+		int[] count = new int[1];
+		findSolutions(n, 0, sol, row, cols, count);
+		return count[0];
+	}
+
+	private void findSolutions(int n, int start, StringBuffer[] sol, int[] row,
+			boolean[] cols, int[] count) {
+		if (start == n) {
+			count[0]++;
+		} else {
+			for (int i = 0; i < n; i++) {
+				if (cols[i])
+					continue;
+				boolean ok = true;
+				for (int j = 0; j < start; j++) {
+					if (Math.abs(start - j) == Math.abs(i - row[j])) {
+						ok = false;
+						break;
+					}
+				}
+				if (ok) {
+					cols[i] = true;
+					sol[start].setCharAt(i, 'Q');
+					row[start] = i;
+					findSolutions(n, start + 1, sol, row, cols, count);
+					row[start] = 0;
+					sol[start].setCharAt(i, '.');
+					cols[i] = false;
+				}
+			}
+		}
+	}
+}

TrappingRainWater.java

@@ -0,0 +1,42 @@
+/**
+ * Given n non-negative integers representing an elevation map where the width
+ * of each bar is 1, compute how much water it is able to trap after raining.
+ * 
+ * For example,
+ * 
+ * Given [0,1,0,2,1,0,1,3,2,1,2,1], return 6.
+ * 
+ * The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In
+ * this case, 6 units of rain water (blue section) are being trapped. Thanks
+ * Marcos for contributing this image!
+ * 
+ */
+
+public class TrappingRainWater {
+	public int trap(int A[], int n) {
+		if (n <= 2)
+			return 0;
+
+		int[] lmh = new int[n];
+		lmh[0] = 0;
+		int maxh = A[0];
+		for (int i = 1; i < n; ++i) {
+			lmh[i] = maxh;
+			if (maxh < A[i])
+				maxh = A[i];
+		}
+		int trapped = 0;
+		maxh = A[n - 1];
+		for (int i = n - 2; i > 0; --i) {
+			int left = lmh[i];
+			int right = maxh;
+			int container = Math.min(left, right);
+			if (container > A[i]) {
+				trapped += container - A[i];
+			}
+			if (maxh < A[i])
+				maxh = A[i];
+		}
+		return trapped;
+	}
+}