Updated 4 solutions

Author: RodneyShag

Chp. 04 - Trees and Graphs/_4_08_First_Common_Ancestor/FirstCommonAncestor.java

@@ -11,13 +11,17 @@
 // 2) Recursive O(n) Favorite
 
 public class FirstCommonAncestor {
- /* Solution 0: If Binary Search Tree, can go down the tree from the root to see where we need to diverge paths */
+ // Solution 0: If Binary Search Tree, can go down the tree from the root to see where we need to diverge paths */
 
- /* Book Solution 1: If we have links to parents, we can save all of node1's parents (ancestors) in a HashSet
-  *  and then see if node2's parents (ancestors) match any of those */
+ // Book Solution 1: If we have links to parents, we can save all of node1's parents (ancestors) in a HashSet
+ //  and then see if node2's parents (ancestors) match any of those
 
- /* Solution 2 - from: http://www.programcreek.com/2014/07/leetcode-lowest-common-ancestor-of-a-binary-tree-java/ */
+ // Solution 2
  public static TreeNode commonAnc(TreeNode root, TreeNode p, TreeNode q) {
+ return dfs(root, p, q);
+ }
+ 
+ private static TreeNode dfs(TreeNode root, TreeNode p, TreeNode q) {
  if (root == null) {
  return null;
  } else if (root == p || root == q) {

Chp. 04 - Trees and Graphs/_4_10_Check_Subtree/CheckSubtree.java

@@ -2,24 +2,8 @@
 
 import common.TreeNode;
 
-// Tests if one tree is subtree of another
-//
-// Solution Runtime Preference
-// ------------------------------------------------------------------
-// 1) Preorder Traversal See analysis at bottom Worth mentioning
-// 2) Recursive search See analysis at bottom Favorite
-
 public class CheckSubtree {
- /* Solution 1
- * - Book says if T1's preorder traversal is substring of T2's preorder traversal, 
- * and same is true for inorder traversals, then T2 is substring of T1
- * - During implementation, we can insert dummy "0" for nulls. This is necessary 
- * to distinguish the 2 trees in book with duplicate values.
- */
 
- /**************/
- /* Solution 2 */
- /**************/
  public static boolean containsTree(TreeNode t1, TreeNode t2) {
  if (t2 == null) { // the empty tree is always a subtree. We do this 
  // check here to avoid doing it every time in subTree.
@@ -56,11 +40,6 @@ public static boolean matchTree(TreeNode p, TreeNode q) {
 // Runtimes: 
 // Let t1 have n nodes and t2 have m nodes
 //
-// ---------- Solution 1
-// Time Complexity: O(n + m) since .isSubstring() is linear time complexity
-// Space Complexity: O(n + m) since we copy the trees
-//
-// ---------- Solution 2
 // Time Complexity: 
 // - O(nm) worst case, but average case is much better since matchTree() usually returns 
 // false immediately, so it's O(n + km) where k is number of occurrences of T2's root in T1

Chp. 16 - More Problems (Moderate)/_16_18_Pattern_Matching/PatternMatching.java

@@ -1,40 +1,43 @@
 package _16_18_Pattern_Matching;
 
 // Algorithm:
-// 0) If pattern is all the same letter (aaaaa... or bbbbb...), treat it as a special case.
-// 1) Invert pattern (if necessary) to have it start with "a" instead of "b"
-// 2) count numAs, numBs
-// 3) try maxLengthA = 1 up to max it could validly be
+// 1) If pattern is all the same letter (aaaaa... or bbbbb...), treat it as a special case.
+// 2) Invert pattern (if necessary) to have it start with "a" instead of "b"
+// 3) count numAs, numBs
+// 4) try maxLengthA = 1 up to max it could validly be
 // - for each maxLengthA, calculate maxLengthB
 // - use a helper function: checkMatch(String value, String pattern, int aLength, int bLength)
 
 public class PatternMatching {
 
- public static boolean matches(String value, String pattern) {
- /* Special case: all same character in pattern */
- if (pattern.indexOf('a') == -1 || pattern.indexOf('b') == -1) {
- return value.length() % pattern.length() == 0; // wrong. must check if pattern properly repeats in value.
+ public static boolean matches(String str, String pattern) {
+ if (str == null || pattern == null || pattern.length() > str.length()) {
+ return false;
+ } else if (pattern.length() == 0) {
+ return str.length() == 0;
+ } else if (pattern.indexOf('a') == -1 || pattern.indexOf('b') == -1) {
+ return checkMatchRepeatingWord(str, pattern);
  }
 
- pattern = invert(pattern);
+ pattern = invertIfNecessary(pattern);
  int numAs = countOf(pattern, 'a');
  int numBs = pattern.length() - numAs;
- int maxLengthA = value.length() / numAs;
+ int maxLengthA = str.length() / numAs;
  for (int lengthA = 1; lengthA <= maxLengthA; lengthA++) {
- int charsForB = value.length() - lengthA * numAs;
+ int charsForB = str.length() - lengthA * numAs;
  if (charsForB % numBs != 0) {
  continue;
  }
  int lengthB = charsForB / numBs;
- if (checkMatch(value, pattern, lengthA, lengthB)) {
+ if (checkMatch(str, pattern, lengthA, lengthB)) {
  return true;
  }
  }
  return false;
  }
 
- /* Changes pattern (if necessary) to start with 'a' instead of 'b'. Example: bbaba becomes aabab */
- private static String invert(String pattern) {
+ // Changes pattern (if necessary) to start with 'a' instead of 'b'. Example: bbaba becomes aabab
+ private static String invertIfNecessary(String pattern) {
  if (pattern.charAt(0) == 'a') {
  return pattern;
  }
@@ -59,22 +62,33 @@ private static int countOf(String str, char ch) {
  return count;
  }
 
- private static boolean checkMatch(String value, String pattern, int aLength, int bLength) {
- /* Grab the 2 words matching "a" and "b" */
+ private static boolean checkMatchRepeatingWord(String str, String pattern) {
+ int wordLength = str.length() / pattern.length();
+ String word = str.substring(0, wordLength);
+ for (int i = 0; i < str.length(); i += word.length()) {
+ if (!str.substring(i, i + word.length()).equals(word)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ 
+ private static boolean checkMatch(String str, String pattern, int aLength, int bLength) {
+ // Grab the 2 words matching "a" and "b"
  int firstBinPattern = pattern.indexOf('b');
- int firstBinValue  = firstBinPattern * aLength;
- String aWord = value.substring(0, aLength);
- String bWord = value.substring(firstBinValue, firstBinValue + bLength);
+ int firstBinValue = firstBinPattern * aLength;
+ String aWord = str.substring(0, aLength);
+ String bWord = str.substring(firstBinValue, firstBinValue + bLength);
 
  int i = 0;
  for (int j = 0; j < pattern.length(); j++) {
  if (pattern.charAt(j) == 'a') {
- if (!value.substring(i, i + aLength).equals(aWord)) {
+ if (!str.substring(i, i + aLength).equals(aWord)) {
  return false;
  }
  i += aLength;
  } else if (pattern.charAt(j) == 'b') {
- if (!value.substring(i, i + bLength).equals(bWord)) {
+ if (!str.substring(i, i + bLength).equals(bWord)) {
  return false;
  }
  i += bLength;
@@ -85,3 +99,4 @@ private static boolean checkMatch(String value, String pattern, int aLength, int
 }
 
 // Time Complexity: O(n^2)
+// Space Complexity: O(n)

Chp. 16 - More Problems (Moderate)/_16_18_Pattern_Matching/Tester.java

@@ -5,7 +5,9 @@ public static void main(String[] args) {
  System.out.println("*** Test 16.18: Pattern Matching");
  test("catcatgocatgo", "aabab");
  test("catcatgocatgo", "bab");
-
+ test("foodfoodfood", "a");
+ test("foodfoodfood", "aa");
+ test("foodfoodfood", "aaa");
  }
 
  private static void test(String value, String pattern) {

Chp. 17 - More Problems (Hard)/_17_09_Kth_Multiple/KthMultiple.java

@@ -1,42 +1,33 @@
 package _17_09_Kth_Multiple;
 
-import java.util.ArrayDeque;
+// Different than book's solution. Algorithm is Method 2 from: https://www.geeksforgeeks.org/ugly-numbers/
 
 public class KthMultiple {
- public static int getKthMagicNumber(int k) { // assuming "k" counts from 1...
- if (k < 1) {
+ public static int getKthMagicNumber(int k) {
+ if (k < 0) {
  return -1;
  }
 
- /* Use each deque as a queue */
- ArrayDeque<Integer> q3 = new ArrayDeque<>();
- ArrayDeque<Integer> q5 = new ArrayDeque<>();
- ArrayDeque<Integer> q7 = new ArrayDeque<>();
+ int[] magic = new int[k];
+ magic[0] = 1;
 
- q3.addLast(3);
- q5.addLast(5);
- q7.addLast(7);
+ int i3 = 0;
+ int i5 = 0;
+ int i7 = 0;
 
- int val = 0;
- for (int i = 1; i <= k; i++) {
- int v3 = q3.peek();
- int v5 = q5.peek();
- int v7 = q7.peek();
- val = Math.min(v3, Math.min(v5, v7)); // minimum of 3 values
- /* We only add certain multiples to the queues (based on trick from book) to avoid duplicates */
- if (val == v3) {
- q3.removeFirst();
- q3.addLast(3 * val);
- q5.addLast(5 * val);
- } else if (val == v5) {
- q5.removeFirst();
- q5.addLast(5 * val);
- } else if (val == v7) {
- q7.removeFirst();
+ for (int i = 1; i < k; i++) {
+ magic[i] = Math.min(magic[i3] * 3, Math.min(magic[i5] * 5, magic[i7] * 7));
+ if (magic[i] == magic[i3] * 3) {
+ i3++;
+ }
+ if (magic[i] == magic[i5] * 5) {
+ i5++;
+ }
+ if (magic[i] == magic[i7] * 7) {
+ i7++;
  }
- q7.addLast(7 * val);
  }
- return val;
+ return magic[k-1];
  }
 }
 

Chp. 17 - More Problems (Hard)/_17_09_Kth_Multiple/Tester.java

@@ -4,7 +4,7 @@ public class Tester {
  public static void main(String[] args) {
  System.out.println("*** Test 17.9: Kth Multiple\n");
  System.out.print("Magic numbers:");
- for (int i = 1; i <= 6; i++) {
+ for (int i = 1; i <= 10; i++) {
  System.out.print(" " + KthMultiple.getKthMagicNumber(i));
  }
  }