Recursion and Dynamic Programming

Author: turingfly

src/chapter08RecursionAndDynamicProgramming/MagicIndex.java

@@ -0,0 +1,59 @@
+package chapter08RecursionAndDynamicProgramming;
+
+/**
+ * 
+ * Problem: A magic index in an array A[0...n - 1] is defined to be an index
+ * such that A[i] = i. Given a sorted array of distinct integers, write a method
+ * to find a magic index, if one exits, in array A.
+ * 
+ * Follow up: what is the value are not distinct?
+ *
+ */
+public class MagicIndex {
+
+	public int magic(int[] array) {
+		return magic(array, 0, array.length - 1);
+	}
+
+	private int magic(int[] array, int left, int right) {
+		if (right < left) {
+			return -1;
+		}
+		int mid = left + (right - left) / 2;
+		if (array[mid] == mid) {
+			return mid;
+		} else if (array[mid] > mid) {
+			return magic(array, left, mid - 1);
+		} else {
+			return magic(array, mid + 1, right);
+		}
+	}
+
+	// follow up
+	public int magic2(int[] array) {
+		return magic2(array, 0, array.length - 1);
+	}
+
+	private int magic2(int[] array, int left, int right) {
+		if (right < left) {
+			return -1;
+		}
+		int mid = left + (right - left) / 2;
+		int midVal = array[mid];
+		if (midVal == mid) {
+			return mid;
+		}
+
+		// search left
+		int leftIndex = Math.min(mid - 1, midVal);
+		int l = magic2(array, left, leftIndex);
+		if (l >= 0) {
+			return l;
+		}
+
+		// search right
+		int rightIndex = Math.max(mid + 1, midVal);
+		int r = magic2(array, rightIndex, right);
+		return r;
+	}
+}

src/chapter08RecursionAndDynamicProgramming/RobotInAGrid.java

@@ -1,10 +1,115 @@
 package chapter08RecursionAndDynamicProgramming;
 
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
 /**
  * 
- * Problem:
+ * Problem: Imagine a robot sitting on the upper left corner of grid with r rows
+ * and c columns. The robot can only move in two directions, right and down, but
+ * certain cells are "off limits" such that the robot cannot step on them.
+ * Design an algorithm to find a path for the robot from the top left to the
+ * bottom right.
  *
  */
 public class RobotInAGrid {
 
+	/**
+	 * Method 1: Duplicate work
+	 * 
+	 * Time Complexity: O(2(r + c)). each path has r + c steps and there are two
+	 * choices we can make at each step.
+	 */
+
+	public List<Point> getPath1(boolean[][] maze) {
+		if (maze == null || maze.length == 0) {
+			return null;
+		}
+		List<Point> res = new ArrayList<>();
+		if (getPath1(maze, maze.length - 1, maze[0].length - 1, res)) {
+			return res;
+		}
+		return null;
+	}
+
+	private boolean getPath1(boolean[][] maze, int row, int col, List<Point> path) {
+		// out of bounds or not available
+		if (!maze[row][col] || col < 0 || row < 0) {
+			return false;
+		}
+		boolean isAtOrigin = (row == 0) && (col == 0);
+		if (getPath1(maze, row, col - 1, path) || getPath1(maze, row - 1, col, path) || isAtOrigin) {
+			Point p = new Point(row, col);
+			path.add(p);
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Method 2:
+	 * 
+	 * Time Complexity: O(rc), we hit each cell just once.
+	 */
+	public List<Point> getPath2(boolean[][] maze) {
+		if (maze == null || maze.length == 0) {
+			return null;
+		}
+		List<Point> res = new ArrayList<>();
+		Set<Point> failedPoints = new HashSet<>();
+		if (getPath2(maze, maze.length - 1, maze[0].length - 1, res, failedPoints)) {
+			return res;
+		}
+		return null;
+	}
+
+	private boolean getPath2(boolean[][] maze, int row, int col, List<Point> path, Set<Point> failedPoints) {
+		// out of bounds or not available
+		if (!maze[row][col] || col < 0 || row < 0) {
+			return false;
+		}
+		Point p = new Point(row, col);
+		if (failedPoints.contains(p)) {
+			return false;
+		}
+		boolean isAtOrigin = (row == 0) && (col == 0);
+		if (getPath2(maze, row, col - 1, path, failedPoints) || getPath2(maze, row - 1, col, path, failedPoints)
+				|| isAtOrigin) {
+			path.add(p);
+			return true;
+		}
+		return false;
+	}
+
 }
+
+class Point {
+	int row;
+	int col;
+
+	public Point(int row, int col) {
+		this.row = row;
+		this.col = col;
+	}
+
+	@Override
+	public String toString() {
+		return "(" + row + "," + col + ")";
+	}
+
+	@Override
+	public int hashCode() {
+		return this.toString().hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if ((o instanceof Point) && ((Point) o).row == this.row && ((Point) o).col == this.col) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+}