feat: add solutions to lcci problem: No.17.11 (doocs#2718)

Author: yanglbme

lcci/17.11.Find Closest/README.md

@@ -20,18 +20,27 @@
 
 ## 解法
 
-### 方法一
+### 方法一：一次遍历
+
+我们用两个指针 $i$ 和 $j$ 分别记录两个单词 $\textit{word1}$ 和 $\textit{word2}$ 最近出现的位置，初始时 $i = \infty$, $j = -\infty$。
+
+接下来我们遍历整个文本文件，对于每个单词 $w$，如果 $w$ 等于 $\textit{word1}$，我们更新 $i = k$，其中 $k$ 是当前单词的下标；如果 $w$ 等于 $\textit{word2}$，我们更新 $j = k$。然后我们更新答案 $ans = \min(ans, |i - j|)$。
+
+遍历结束后，我们返回答案 $ans$。
+
+时间复杂度 $O(n)$，其中 $n$ 是文本文件中的单词数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 ```python
 class Solution:
     def findClosest(self, words: List[str], word1: str, word2: str) -> int:
-        i, j, ans = 1e5, -1e5, 1e5
-        for k, word in enumerate(words):
-            if word == word1:
+        i, j = inf, -inf
+        ans = inf
+        for k, w in enumerate(words):
+            if w == word1:
                 i = k
-            elif word == word2:
+            elif w == word2:
                 j = k
             ans = min(ans, abs(i - j))
         return ans
@@ -40,12 +49,12 @@ class Solution:
 ```java
 class Solution {
     public int findClosest(String[] words, String word1, String word2) {
-        int i = 100000, j = -100000, ans = 100000;
+        final int inf = 1 << 29;
+        int i = inf, j = -inf, ans = inf;
         for (int k = 0; k < words.length; ++k) {
-            String word = words[k];
-            if (word.equals(word1)) {
+            if (words[k].equals(word1)) {
                 i = k;
-            } else if (word.equals(word2)) {
+            } else if (words[k].equals(word2)) {
                 j = k;
             }
             ans = Math.min(ans, Math.abs(i - j));
@@ -59,13 +68,15 @@ class Solution {
 class Solution {
 public:
     int findClosest(vector<string>& words, string word1, string word2) {
-        int i = 1e5, j = -1e5, ans = 1e5;
+        const int inf = 1 << 29;
+        int i = inf, j = -inf;
+        int ans = inf;
         for (int k = 0; k < words.size(); ++k) {
-            string word = words[k];
-            if (word == word1)
+            if (words[k] == word1) {
                 i = k;
-            else if (word == word2)
+            } else if (words[k] == word2) {
                 j = k;
+            }
             ans = min(ans, abs(i - j));
         }
         return ans;
@@ -75,70 +86,70 @@ public:
 
 ```go
 func findClosest(words []string, word1 string, word2 string) int {
-	i, j, ans := 100000, -100000, 100000
-	for k, word := range words {
-		if word == word1 {
+	const inf int = 1 << 29
+	i, j, ans := inf, -inf, inf
+	for k, w := range words {
+		if w == word1 {
 			i = k
-		} else if word == word2 {
+		} else if w == word2 {
 			j = k
 		}
-		ans = min(ans, abs(i-j))
+		ans = min(ans, max(i-j, j-i))
 	}
 	return ans
 }
-
-func abs(x int) int {
-	if x < 0 {
-		return -x
-	}
-	return x
-}
 ```
 
 ```ts
 function findClosest(words: string[], word1: string, word2: string): number {
-    let index1 = 100000;
-    let index2 = -100000;
-    let res = 100000;
-    const n = words.length;
-    for (let i = 0; i < n; i++) {
-        const word = words[i];
-        if (word === word1) {
-            index1 = i;
-        } else if (word === word2) {
-            index2 = i;
+    let [i, j, ans] = [Infinity, -Infinity, Infinity];
+    for (let k = 0; k < words.length; ++k) {
+        if (words[k] === word1) {
+            i = k;
+        } else if (words[k] === word2) {
+            j = k;
         }
-        res = Math.min(res, Math.abs(index1 - index2));
+        ans = Math.min(ans, Math.abs(i - j));
     }
-    return res;
+    return ans;
 }
 ```
 
 ```rust
 impl Solution {
     pub fn find_closest(words: Vec<String>, word1: String, word2: String) -> i32 {
-        let mut res = i32::MAX;
-        let mut index1 = -1;
-        let mut index2 = -1;
-        for (i, word) in words.iter().enumerate() {
-            let i = i as i32;
-            if word.eq(&word1) {
-                index1 = i;
-            } else if word.eq(&word2) {
-                index2 = i;
+        let mut ans = i32::MAX;
+        let mut i = -1;
+        let mut j = -1;
+        for (k, w) in words.iter().enumerate() {
+            let k = k as i32;
+            if w.eq(&word1) {
+                i = k;
+            } else if w.eq(&word2) {
+                j = k;
             }
-            if index1 != -1 && index2 != -1 {
-                res = res.min((index1 - index2).abs());
+            if i != -1 && j != -1 {
+                ans = ans.min((i - j).abs());
             }
         }
-        res
+        ans
     }
 }
 ```
 
 <!-- tabs:end -->
 
-### 方法二
+### 方法二：哈希表 + 双指针
+
+我们可以用哈希表 $d$ 记录每个单词出现的位置，然后对于每一对 $\textit{word1}$ 和 $\textit{word2}$，我们可以通过双指针的方法找到它们的最短距离。
+
+我们遍历整个文本文件，对于每个单词 $w$，我们将 $w$ 的下标加入到 $d[w]$ 中。
+
+接下来我们找到 $\textit{word1}$ 和 $\textit{word2}$ 在文本文件中出现的位置，分别用 $idx1$ 和 $idx2$ 表示。然后我们用两个指针 $i$ 和 $j$ 分别指向 $idx1$ 和 $idx2$，初始时 $i = 0$, $j = 0$。
+
+接下来我们遍历 $idx1$ 和 $idx2$，每次我们更新答案 $ans = \min(ans, |idx1[i] - idx2[j]|)$，然后我们将 $i$ 和 $j$ 中较小的那个指针向后移动一位。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是文本文件中的单词数。
 
 <!-- tabs:start -->
 
@@ -148,7 +159,7 @@ class Solution:
         d = defaultdict(list)
         for i, w in enumerate(words):
             d[w].append(i)
-        ans = 1e5
+        ans = inf
         idx1, idx2 = d[word1], d[word2]
         i, j, m, n = 0, 0, len(idx1), len(idx2)
         while i < m and j < n:
@@ -169,7 +180,7 @@ class Solution {
         }
         List<Integer> idx1 = d.get(word1), idx2 = d.get(word2);
         int i = 0, j = 0, m = idx1.size(), n = idx2.size();
-        int ans = 100000;
+        int ans = 1 << 29;
         while (i < m && j < n) {
             int t = Math.abs(idx1.get(i) - idx2.get(j));
             ans = Math.min(ans, t);
@@ -189,17 +200,20 @@ class Solution {
 public:
     int findClosest(vector<string>& words, string word1, string word2) {
         unordered_map<string, vector<int>> d;
-        for (int i = 0; i < words.size(); ++i) d[words[i]].push_back(i);
+        for (int i = 0; i < words.size(); ++i) {
+            d[words[i]].push_back(i);
+        }
         vector<int> idx1 = d[word1], idx2 = d[word2];
         int i = 0, j = 0, m = idx1.size(), n = idx2.size();
         int ans = 1e5;
         while (i < m && j < n) {
             int t = abs(idx1[i] - idx2[j]);
             ans = min(ans, t);
-            if (idx1[i] < idx2[j])
+            if (idx1[i] < idx2[j]) {
                 ++i;
-            else
+            } else {
                 ++j;
+            }
         }
         return ans;
     }
@@ -214,9 +228,9 @@ func findClosest(words []string, word1 string, word2 string) int {
 	}
 	idx1, idx2 := d[word1], d[word2]
 	i, j, m, n := 0, 0, len(idx1), len(idx2)
-	ans := 100000
+	ans := 1 << 30
 	for i < m && j < n {
-		t := abs(idx1[i] - idx2[j])
+		t := max(idx1[i]-idx2[j], idx2[j]-idx1[i])
 		if t < ans {
 			ans = t
 		}
@@ -228,12 +242,28 @@ func findClosest(words []string, word1 string, word2 string) int {
 	}
 	return ans
 }
+```
 
-func abs(x int) int {
-	if x < 0 {
-		return -x
-	}
-	return x
+```ts
+function findClosest(words: string[], word1: string, word2: string): number {
+    const d: Map<string, number[]> = new Map();
+    for (let i = 0; i < words.length; ++i) {
+        if (!d.has(words[i])) {
+            d.set(words[i], []);
+        }
+        d.get(words[i])!.push(i);
+    }
+    let [i, j] = [0, 0];
+    let ans = Infinity;
+    while (i < d.get(word1)!.length && j < d.get(word2)!.length) {
+        ans = Math.min(ans, Math.abs(d.get(word1)![i] - d.get(word2)![j]));
+        if (d.get(word1)![i] < d.get(word2)![j]) {
+            ++i;
+        } else {
+            ++j;
+        }
+    }
+    return ans;
 }
 ```