shortest word distance 1,2,3 done

rampatra · rampatra · commit 067c0af3c298 · 2019-08-02T14:37:17.000+01:00
diff --git a/src/main/java/com/leetcode/arrays/ShortestWordDistance.java b/src/main/java/com/leetcode/arrays/ShortestWordDistance.java
@@ -4,7 +4,7 @@
 
 /**
  * Level: Easy
- * Problem Link:
+ * Problem Link: https://leetcode.com/problems/shortest-word-distance/
  * Problem Description:
  * Given a list of words and two words word1 and word2, return the shortest distance between these two words in the
  * list of words.
@@ -34,18 +34,20 @@ public class ShortestWordDistance {
      * @return
      */
     public static int findShortestDistance(String[] words, String word1, String word2) {
-        int startWord1 = Integer.MIN_VALUE;
-        int startWord2 = Integer.MAX_VALUE;
+        int indexWord1 = -1;
+        int indexWord2 = -1;
         int minDistance = Integer.MAX_VALUE;
 
         for (int i = 0; i < words.length; i++) {
             if (words[i].equals(word1)) {
-                startWord1 = i;
+                indexWord1 = i;
             }
             if (words[i].equals(word2)) {
-                startWord2 = i;
+                indexWord2 = i;
+            }
+            if (indexWord1 != -1 && indexWord2 != -1) {
+                minDistance = Math.min(minDistance, Math.abs(indexWord1 - indexWord2));
             }
-            minDistance = Math.min(minDistance, Math.abs(startWord1 - startWord2));
         }
 
         return minDistance;
@@ -54,8 +56,12 @@ public static int findShortestDistance(String[] words, String word1, String word
     public static void main(String[] args) {
         assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
                 "practice", "coding"));
+        assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "coding", "practice"));
         assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
                 "makes", "coding"));
+        assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "makes", "perfect"));
         assertEquals(0, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
                 "perfect", "perfect"));
         assertEquals(0, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
diff --git a/src/main/java/com/leetcode/arrays/ShortestWordDistanceIII.java b/src/main/java/com/leetcode/arrays/ShortestWordDistanceIII.java
@@ -0,0 +1,80 @@
+package com.leetcode.arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Level: Easy
+ * Problem Link: https://leetcode.com/problems/shortest-word-distance-iii/
+ * Problem Description:
+ * This is a follow-up problem of {@link ShortestWordDistance}. The only difference is that now word1 could be the
+ * same as word2.
+ * <p>
+ * Given a list of words and two words word1 and word2, return the shortest distance between these two words in the list.
+ * word1 and word2 may be the same and they represent two individual words in the list.
+ * <p>
+ * For example,
+ * Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+ * Given word1 = “makes”, word2 = “coding”, return 1.
+ * Given word1 = "makes", word2 = "makes", return 3.
+ * <p>
+ * Note: You may assume word1 and word2 are both in the list. If they are same then it's guaranteed that there are
+ * two occurrences of the same.
+ *
+ * @author rampatra
+ * @since 2019-07-31
+ */
+public class ShortestWordDistanceIII {
+
+    /**
+     * Time Complexity:
+     * Space Complexity:
+     * TODO
+     *
+     * @param words
+     * @param word1
+     * @param word2
+     * @return
+     */
+    public static int findShortestDistance(String[] words, String word1, String word2) {
+        int indexWord1 = -1;
+        int indexWord2 = -1;
+        int minDistance = Integer.MAX_VALUE;
+
+        for (int i = 0; i < words.length; i++) {
+            if (words[i].equals(word1)) {
+                // if both words are same and the first index is already set then do nothing
+                if (word1.equals(word2) && indexWord1 != -1) {
+
+                } else {
+                    indexWord1 = i;
+                }
+            }
+            if (words[i].equals(word2)) {
+                // if both words are same and i is same as first index then it implies its the
+                // first occurrence, skip and continue look for the second occurrence
+                if (word1.equals(word2) && i == indexWord1) {
+                    continue;
+                }
+                indexWord2 = i;
+            }
+            if (indexWord1 != -1 && indexWord2 != -1) {
+                minDistance = Math.min(minDistance, Math.abs(indexWord1 - indexWord2));
+            }
+        }
+
+        return minDistance;
+    }
+
+    public static void main(String[] args) {
+        assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "makes", "makes"));
+        assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "coding", "practice"));
+        assertEquals(3, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "practice", "coding"));
+        assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "makes", "coding"));
+        assertEquals(1, findShortestDistance(new String[]{"practice", "makes", "perfect", "coding", "makes"},
+                "makes", "perfect"));
+    }
+}
diff --git a/src/main/java/com/leetcode/maps/ShortestWordDistanceII.java b/src/main/java/com/leetcode/maps/ShortestWordDistanceII.java
@@ -1,34 +1,82 @@
 package com.leetcode.maps;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 /**
  * Level: Medium
  * Problem Link: https://leetcode.com/problems/shortest-word-distance-ii/ (premium)
  * Problem Description:
- * This is a follow up of Shortest Word Distance. The only difference is now you are given the list of words and
- * your method will be called repeatedly many times with different parameters. How would you optimize it?
- * <p>
  * Design a class which receives a list of words in the constructor, and implements a method that takes two words
- * word1 and word2 and return the shortest distance between these two words in the list.
+ * word1 and word2 and return the shortest distance between these two words in the list. Your method will be called
+ * repeatedly many times with different parameters. For a simpler variant, see {@link com.leetcode.arrays.ShortestWordDistance}.
  * <p>
- * Example 1:
+ * Examples:
  * Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
- * Given word1 = "coding”, word2 = "practice”, return 3.
- * Given word1 = "makes", word2 = "coding", return 1.
  * <p>
- * Note: You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.
+ * Input1: word1 = “coding”, word2 = “practice”
+ * Output1: 3
+ * <p>
+ * Input2: word1 = "makes", word2 = "coding"
+ * Output2: 1
  * <p>
- * Lastly, for a simpler variant, see {@link com.leetcode.arrays.ShortestWordDistance}.
+ * Note: You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.
  *
  * @author rampatra
  * @since 2019-07-31
  */
 public class ShortestWordDistanceII {
 
-    public static int findShortestDistance(String[] words, String word1, String word2) {
-        return -1;
+    private String[] words;
+    private Map<String, List<Integer>> wordsToIndexesMap;
+
+    ShortestWordDistanceII(String[] words) {
+        this.words = words;
+        this.wordsToIndexesMap = getWordsToIndexesMap();
     }
 
-    public static void main(String[] args) {
+    public int findShortestDistance(String word1, String word2) {
+        return findShortestDistance(wordsToIndexesMap.get(word1), wordsToIndexesMap.get(word2));
+    }
 
+    private int findShortestDistance(List<Integer> indexes1, List<Integer> indexes2) {
+        int minDistance = Integer.MAX_VALUE;
+
+        for (int i = 0, j = 0; i < indexes1.size() && j < indexes2.size(); ) {
+            if (indexes1.get(i) <= indexes2.get(j)) {
+                minDistance = Math.min(minDistance, Math.abs(indexes1.get(i) - indexes2.get(j)));
+                i++;
+            } else if (indexes1.get(i) > indexes2.get(j)) {
+                minDistance = Math.min(minDistance, Math.abs(indexes1.get(i) - indexes2.get(j)));
+                j++;
+            }
+        }
+
+        return minDistance;
+    }
+
+    private Map<String, List<Integer>> getWordsToIndexesMap() {
+        Map<String, List<Integer>> wordsToIndexesMap = new HashMap<>();
+
+        for (int i = 0; i < words.length; i++) {
+            wordsToIndexesMap.putIfAbsent(words[i], new ArrayList<>());
+            wordsToIndexesMap.get(words[i]).add(i);
+        }
+        return wordsToIndexesMap;
+    }
+
+    public static void main(String[] args) {
+        ShortestWordDistanceII shortestWordDist = new ShortestWordDistanceII(new String[]{"practice", "makes", "perfect", "coding", "makes"});
+        assertEquals(1, shortestWordDist.findShortestDistance("coding", "makes"));
+        assertEquals(1, shortestWordDist.findShortestDistance("perfect", "makes"));
+        assertEquals(1, shortestWordDist.findShortestDistance("practice", "makes"));
+        assertEquals(1, shortestWordDist.findShortestDistance("makes", "practice"));
+        assertEquals(3, shortestWordDist.findShortestDistance("coding", "practice"));
+        assertEquals(0, shortestWordDist.findShortestDistance("coding", "coding"));
+        assertEquals(0, shortestWordDist.findShortestDistance("makes", "makes"));
     }
-}
+}
diff --git a/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValue.java b/src/main/java/com/leetcode/trees/ClosestBinarySearchTreeValue.java
@@ -6,14 +6,18 @@
  * Level: Easy
  * Problem Link: https://leetcode.com/problems/closest-binary-search-tree-value/ (premium)
  * Problem Description:
+ * Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target.
+ * <p>
+ * Note:
+ * - Given target value is a floating point.
+ * - You are guaranteed to have only one unique value in the BST that is closest to the target.
  *
  * @author rampatra
  * @since 2019-07-31
  */
 public class ClosestBinarySearchTreeValue {
 
     /**
-     *
      * @param node
      * @param parentNode
      * @param val
