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));
         }
     }