feat: add solutions to lc problem: No.1182

No.1182. Shortest Distance to Target Color

Author: yanglbme

solution/1100-1199/1182.Shortest Distance to Target Color/README.md

@@ -50,9 +50,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-二分查找。
+**方法一：预处理**
 
-先用哈希表记录每种颜色的索引位置。然后遍历 `queries`，如果当前 `color` 不在哈希表中，说明不存在解决方案，此时此 `query` 对应的结果元素是 `-1`。否则，在哈希表中取出当前 `color` 对应的索引列表，二分查找即可。
+我们可以预处理出每个位置到左边最近的颜色 $1$,$2$,$3$ 的距离，以及每个位置到右边最近的颜色 $1$,$2$,$3$ 的距离，记录在数组 $left$ 和 $right$ 中。初始时 $left[0][1] = left[0][2] = left[0][3] = -\infty$，而 $right[n][1] = right[n][2] = right[n][3] = \infty$，其中 $n$ 是数组 $colors$ 的长度。
+
+然后对于每个查询 $(i, c)$，最小距离就是 $d = \min(i - left[i + 1][c - 1], right[i][c - 1][i] - i)$，如果 $d \gt n$，则不存在解决方案，此次查询的答案为 $-1$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $colors$ 的长度。
 
 <!-- tabs:start -->
 
@@ -62,32 +66,23 @@
 
 ```python
 class Solution:
-    def shortestDistanceColor(
-        self, colors: List[int], queries: List[List[int]]
-    ) -> List[int]:
-        color_indexes = defaultdict(list)
-        for i, c in enumerate(colors):
-            color_indexes[c].append(i)
-        res = []
+    def shortestDistanceColor(self, colors: List[int], queries: List[List[int]]) -> List[int]:
+        n = len(colors)
+        right = [[inf] * 3 for _ in range(n + 1)]
+        for i in range(n - 1, -1, -1):
+            for j in range(3):
+                right[i][j] = right[i + 1][j]
+            right[i][colors[i] - 1] = i
+        left = [[-inf] * 3 for _ in range(n + 1)]
+        for i, c in enumerate(colors, 1):
+            for j in range(3):
+                left[i][j] = left[i - 1][j]
+            left[i][c - 1] = i - 1
+        ans = []
         for i, c in queries:
-            if c not in color_indexes:
-                res.append(-1)
-            else:
-                t = color_indexes[c]
-                left, right = 0, len(t) - 1
-                while left < right:
-                    mid = (left + right) >> 1
-                    if t[mid] >= i:
-                        right = mid
-                    else:
-                        left = mid + 1
-                val = abs(t[left] - i)
-                if left > 0:
-                    val = min(val, abs(t[left - 1] - i))
-                if left < len(t) - 1:
-                    val = min(val, abs(t[left + 1] - i))
-                res.append(val)
-        return res
+            d = min(i - left[i + 1][c - 1], right[i][c - 1] - i)
+            ans.append(-1 if d > n else d)
+        return ans
 ```
 
 ### **Java**
@@ -97,39 +92,144 @@ class Solution:
 ```java
 class Solution {
     public List<Integer> shortestDistanceColor(int[] colors, int[][] queries) {
-        Map<Integer, List<Integer>> colorIndexes = new HashMap<>();
-        for (int i = 0; i < colors.length; ++i) {
-            int c = colors[i];
-            colorIndexes.computeIfAbsent(c, k -> new ArrayList<>()).add(i);
-        }
-        List<Integer> res = new ArrayList<>();
-        for (int[] query : queries) {
-            int i = query[0], c = query[1];
-            if (!colorIndexes.containsKey(c)) {
-                res.add(-1);
-                continue;
+        int n = colors.length;
+        final int inf = 1 << 30;
+        int[][] right = new int[n + 1][3];
+        Arrays.fill(right[n], inf);
+        for (int i = n - 1; i >= 0; --i) {
+            for (int j = 0; j < 3; ++j) {
+                right[i][j] = right[i + 1][j];
             }
-            List<Integer> t = colorIndexes.get(c);
-            int left = 0, right = t.size() - 1;
-            while (left < right) {
-                int mid = (left + right) >> 1;
-                if (t.get(mid) >= i) {
-                    right = mid;
-                } else {
-                    left = mid + 1;
-                }
+            right[i][colors[i] - 1] = i;
+        }
+        int[][] left = new int[n + 1][3];
+        Arrays.fill(left[0], -inf);
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < 3; ++j) {
+                left[i][j] = left[i - 1][j];
             }
-            int val = Math.abs(t.get(left) - i);
-            if (left > 0) {
-                val = Math.min(val, Math.abs(t.get(left - 1) - i));
+            left[i][colors[i - 1] - 1] = i - 1;
+        }
+        List<Integer> ans = new ArrayList<>();
+        for (int[] q : queries) {
+            int i = q[0], c = q[1] - 1;
+            int d = Math.min(i - left[i + 1][c], right[i][c] - i);
+            ans.add(d > n ? -1 : d);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> shortestDistanceColor(vector<int>& colors, vector<vector<int>>& queries) {
+        int n = colors.size();
+        int right[n + 1][3];
+        const int inf = 1 << 30;
+        fill(right[n], right[n] + 3, inf);
+        for (int i = n - 1; i >= 0; --i) {
+            for (int j = 0; j < 3; ++j) {
+                right[i][j] = right[i + 1][j];
             }
-            if (left < t.size() - 1) {
-                val = Math.min(val, Math.abs(t.get(left + 1) - i));
+            right[i][colors[i] - 1] = i;
+        }
+        int left[n + 1][3];
+        fill(left[0], left[0] + 3, -inf);
+        for (int i = 1; i <= n; ++i) {
+            for (int j = 0; j < 3; ++j) {
+                left[i][j] = left[i - 1][j];
             }
-            res.add(val);
+            left[i][colors[i - 1] - 1] = i - 1;
         }
-        return res;
+        vector<int> ans;
+        for (auto& q : queries) {
+            int i = q[0], c = q[1] - 1;
+            int d = min(i - left[i + 1][c], right[i][c] - i);
+            ans.push_back(d > n ? -1 : d);
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func shortestDistanceColor(colors []int, queries [][]int) (ans []int) {
+	n := len(colors)
+	const inf = 1 << 30
+	right := make([][3]int, n+1)
+	left := make([][3]int, n+1)
+	right[n] = [3]int{inf, inf, inf}
+	left[0] = [3]int{-inf, -inf, -inf}
+	for i := n - 1; i >= 0; i-- {
+		for j := 0; j < 3; j++ {
+			right[i][j] = right[i+1][j]
+		}
+		right[i][colors[i]-1] = i
+	}
+	for i := 1; i <= n; i++ {
+		for j := 0; j < 3; j++ {
+			left[i][j] = left[i-1][j]
+		}
+		left[i][colors[i-1]-1] = i - 1
+	}
+	for _, q := range queries {
+		i, c := q[0], q[1]-1
+		d := min(i-left[i+1][c], right[i][c]-i)
+		if d > n {
+			d = -1
+		}
+		ans = append(ans, d)
+	}
+	return
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+```
+
+### **TypeScript**
+
+```ts
+function shortestDistanceColor(
+    colors: number[],
+    queries: number[][],
+): number[] {
+    const n = colors.length;
+    const inf = 1 << 30;
+    const right: number[][] = Array(n + 1)
+        .fill(0)
+        .map(() => Array(3).fill(inf));
+    const left: number[][] = Array(n + 1)
+        .fill(0)
+        .map(() => Array(3).fill(-inf));
+    for (let i = n - 1; i >= 0; --i) {
+        for (let j = 0; j < 3; ++j) {
+            right[i][j] = right[i + 1][j];
+        }
+        right[i][colors[i] - 1] = i;
+    }
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 0; j < 3; ++j) {
+            left[i][j] = left[i - 1][j];
+        }
+        left[i][colors[i - 1] - 1] = i - 1;
+    }
+    const ans: number[] = [];
+    for (const [i, c] of queries) {
+        const d = Math.min(i - left[i + 1][c - 1], right[i][c - 1] - i);
+        ans.push(d > n ? -1 : d);
     }
+    return ans;
 }
 ```