Recursion and Dynamic Programming

Author: turingfly

src/chapter08RecursionAndDynamicProgramming/PowerSet.java

@@ -0,0 +1,60 @@
+package chapter08RecursionAndDynamicProgramming;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import chapter05BitManipulation.Conversion;
+
+/**
+ * 
+ * Problem: Write a method to return all subsets of a set.
+ *
+ */
+public class PowerSet {
+	/**
+	 * Method 1: DFS
+	 */
+	public List<List<Integer>> subsets(int[] nums) {
+		Arrays.sort(nums);
+		List<List<Integer>> res = new ArrayList<>();
+		List<Integer> cur = new ArrayList<>();
+		helper(nums, 0, res, cur);
+		return res;
+	}
+
+	private void helper(int[] nums, int index, List<List<Integer>> res, List<Integer> cur) {
+		res.add(new ArrayList<Integer>(cur));
+		for (int i = index; i < nums.length; i++) {
+			cur.add(nums[i]);
+			helper(nums, i + 1, res, cur);
+			cur.remove(cur.size() - 1);
+		}
+	}
+
+	/**
+	 * Combinatorics
+	 */
+	public List<List<Integer>> subsets2(List<Integer> set) {
+		List<List<Integer>> res = new ArrayList<>();
+		int max = 1 << set.size(); // compute 2^N
+		for (int i = 0; i < max; i++) {
+			List<Integer> cur = convertIntToSet(set, i);
+			res.add(cur);
+		}
+		return res;
+	}
+
+	private List<Integer> convertIntToSet(List<Integer> set, int x) {
+		List<Integer> res = new ArrayList<>();
+		int index = 0;
+		for (int i = x; i > 0; i >>= 1) {
+			if ((i & 1) == 1) {
+				res.add(set.get(index));
+			}
+			index++;
+		}
+		return res;
+	}
+
+}

src/chapter08RecursionAndDynamicProgramming/RecursiveMultiply.java

@@ -0,0 +1,94 @@
+package chapter08RecursionAndDynamicProgramming;
+
+/**
+ * 
+ * Problem: Write a recursive function to multiply two positive integers without
+ * using the * operator(or / operator). You can use addition, subtraction, and
+ * bit shifting, but you should minimize the number of those operations.
+ *
+ */
+public class RecursiveMultiply {
+
+	/**
+	 * Method 1: Duplicate work
+	 */
+	public int minProduct1(int a, int b) {
+		int bigger = a < b ? b : a;
+		int smaller = a < b ? a : b;
+		return helper1(smaller, bigger);
+	}
+
+	private int helper1(int smaller, int bigger) {
+		if (smaller == 0) {
+			return 0;
+		} else if (smaller == 1) {
+			return bigger;
+		}
+		// compute half, if uneven, compute other half. if even, double it.
+		int s = smaller >> 1;
+		int side1 = helper1(s, bigger);
+		int side2 = side1;
+		if (smaller % 2 == 1) {
+			side2 = helper1(smaller - s, bigger);
+		}
+		return side1 + side2;
+	}
+
+	/**
+	 * Method 2: use memorization to cache the results.
+	 */
+	public int minProduct2(int a, int b) {
+		int bigger = a < b ? b : a;
+		int smaller = a < b ? a : b;
+		int memo[] = new int[smaller + 1];
+		return helper2(smaller, bigger, memo);
+	}
+
+	private int helper2(int smaller, int bigger, int[] memo) {
+		if (smaller == 0) {
+			return 0;
+		} else if (smaller == 1) {
+			return bigger;
+		} else if (memo[smaller] > 0) {
+			return memo[smaller];
+		}
+		// compute half, if uneven, compute other half. if even, double it.
+		int s = smaller >> 1;
+		int side1 = helper1(s, bigger);
+		int side2 = side1;
+		if (smaller % 2 == 1) {
+			side2 = helper2(smaller - s, bigger, memo);
+		}
+		memo[smaller] = side1 + side2;
+		return memo[smaller];
+	}
+
+	/**
+	 * Method 3:minProd(31, 35) = 2 * minProd(15, 35) + 35
+	 * 
+	 * The function just recurses straight downwards. It will never repeat the
+	 * same call, so there's no need to cache any information.
+	 * 
+	 * Time Complexity: O(logs), where s is the smaller of the tow numbers.
+	 */
+	public int minProduct3(int a, int b) {
+		int bigger = a < b ? b : a;
+		int smaller = a < b ? a : b;
+		return helper3(smaller, bigger);
+	}
+
+	private int helper3(int smaller, int bigger) {
+		if (smaller == 0) {
+			return 0;
+		} else if (smaller == 1) {
+			return bigger;
+		}
+		int s = smaller >> 1;
+		int halfProd = helper3(s, bigger);
+		if (smaller % 2 == 0) {
+			return halfProd + halfProd;
+		} else {
+			return halfProd + halfProd + bigger;
+		}
+	}
+}

src/chapter08RecursionAndDynamicProgramming/TowersOfHanoi.java

@@ -0,0 +1,57 @@
+package chapter08RecursionAndDynamicProgramming;
+
+import java.util.Stack;
+
+/**
+ * 
+ * Problem:
+ *
+ */
+public class TowersOfHanoi {
+	public static void main(String[] args) {
+		int n = 3;
+		Tower[] towers = new Tower[n];
+		for (int i = 0; i < 3; i++) {
+			towers[i] = new Tower(i);
+		}
+		for (int i = n - 1; i >= 0; i--) {
+			towers[0].add(i);
+		}
+		towers[0].moveDisks(n, towers[2], towers[1]);
+	}
+}
+
+class Tower {
+	private Stack<Integer> disks;
+	private int index;
+
+	public Tower(int index) {
+		disks = new Stack<>();
+		this.index = index;
+	}
+
+	public int getIndex() {
+		return index;
+	}
+
+	public void add(int d) {
+		if (!disks.isEmpty() && disks.peek() <= d) {
+			System.out.println("ERROR placing disk" + d);
+		} else {
+			disks.add(d);
+		}
+	}
+
+	public void moveToTop(Tower t) {
+		int top = disks.pop();
+		t.add(top);
+	}
+
+	public void moveDisks(int n, Tower destination, Tower buffer) {
+		if (n > 0) {
+			moveDisks(n - 1, buffer, destination);
+			moveToTop(destination);
+			buffer.moveDisks(n - 1, destination, this);
+		}
+	}
+}