@@ -70,32 +70,198 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3400-3499/3488.Cl
7070
7171<!-- solution:start -->
7272
73- ### 方法一
73+ ### 方法一:环形数组 + 哈希表
74+ 75+ 根据题目描述,我们需要找出数组每个元素与上一个相同元素的最小距离,以及与下一个相同元素的最小距离。并且,由于数组是循环的,所以我们需要考虑数组的环形特性,我们可以将数组扩展为原数组的两倍,然后使用哈希表 $\textit{left}$ 和 $\textit{right}$ 分别记录每个元素上一次出现的位置和下一次出现的位置,计算出每个位置的元素与另一个相同元素的最小距离,记录在数组 $\textit{d}$ 中。最后,我们遍历查询,对于每个查询 $i,ドル我们取 $\textit{d}[ i] $ 和 $\textit{d}[ i+n] $ 中的最小值,如果该值大于等于 $n,ドル则说明不存在与查询元素相同的元素,返回 $-1,ドル否则返回该值。
76+ 77+ 时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{nums}$ 的长度。
7478
7579<!-- tabs:start -->
7680
7781#### Python3
7882
7983``` python
80- 84+ class Solution :
85+ def solveQueries (self nums : List[int ], queries : List[int ]) -> List[int ]:
86+ n = len (nums)
87+ m = n << 1
88+ d = [m] * m
89+ left = {}
90+ for i in range (m):
91+ x = nums[i % n]
92+ if x in left:
93+ d[i] = min (d[i], i - left[x])
94+ left[x] = i
95+ right = {}
96+ for i in range (m - 1 , - 1 , - 1 ):
97+ x = nums[i % n]
98+ if x in right:
99+ d[i] = min (d[i], right[x] - i)
100+ right[x] = i
101+ for i in range (n):
102+ d[i] = min (d[i], d[i + n])
103+ return [- 1 if d[i] >= n else d[i] for i in queries]
81104```
82105
83106#### Java
84107
85108``` java
86- 109+ class Solution {
110+ public List<Integer > solveQueries (int [] nums , int [] queries ) {
111+ int n = nums. length;
112+ int m = n * 2 ;
113+ int [] d = new int [m];
114+ Arrays . fill(d, m);
115+ 116+ Map<Integer , Integer > left = new HashMap<> ();
117+ for (int i = 0 ; i < m; i++ ) {
118+ int x = nums[i % n];
119+ if (left. containsKey(x)) {
120+ d[i] = Math . min(d[i], i - left. get(x));
121+ }
122+ left. put(x, i);
123+ }
124+ 125+ Map<Integer , Integer > right = new HashMap<> ();
126+ for (int i = m - 1 ; i >= 0 ; i-- ) {
127+ int x = nums[i % n];
128+ if (right. containsKey(x)) {
129+ d[i] = Math . min(d[i], right. get(x) - i);
130+ }
131+ right. put(x, i);
132+ }
133+ 134+ for (int i = 0 ; i < n; i++ ) {
135+ d[i] = Math . min(d[i], d[i + n]);
136+ }
137+ 138+ List<Integer > ans = new ArrayList<> ();
139+ for (int query : queries) {
140+ ans. add(d[query] >= n ? - 1 : d[query]);
141+ }
142+ return ans;
143+ }
144+ }
87145```
88146
89147#### C++
90148
91149``` cpp
92- 150+ class Solution {
151+ public:
152+ vector<int > solveQueries(vector<int >& nums, vector<int >& queries) {
153+ int n = nums.size();
154+ int m = n * 2;
155+ vector<int > d(m, m);
156+ 157+ unordered_map<int, int> left;
158+ for (int i = 0; i < m; i++) {
159+ int x = nums[i % n];
160+ if (left.count(x)) {
161+ d[i] = min(d[i], i - left[x]);
162+ }
163+ left[x] = i;
164+ }
165+ 166+ unordered_map<int , int > right;
167+ for (int i = m - 1 ; i >= 0 ; i--) {
168+ int x = nums[i % n];
169+ if (right.count(x)) {
170+ d[i] = min(d[i], right[x] - i);
171+ }
172+ right[x] = i;
173+ }
174+ 175+ for (int i = 0; i < n; i++) {
176+ d[i] = min(d[i], d[i + n]);
177+ }
178+ 179+ vector<int> ans;
180+ for (int query : queries) {
181+ ans.push_back(d[query] >= n ? -1 : d[query]);
182+ }
183+ return ans;
184+ }
185+ };
93186```
94187
95188#### Go
96189
97190``` go
191+ func solveQueries (nums []int , queries []int ) []int {
192+ n := len (nums)
193+ m := n * 2
194+ d := make ([]int , m)
195+ for i := range d {
196+ d[i] = m
197+ }
198+ 199+ left := make (map [int ]int )
200+ for i := 0 ; i < m; i++ {
201+ x := nums[i%n]
202+ if idx , exists := left[x]; exists {
203+ d[i] = min (d[i], i-idx)
204+ }
205+ left[x] = i
206+ }
207+ 208+ right := make (map [int ]int )
209+ for i := m - 1 ; i >= 0 ; i-- {
210+ x := nums[i%n]
211+ if idx , exists := right[x]; exists {
212+ d[i] = min (d[i], idx-i)
213+ }
214+ right[x] = i
215+ }
216+ 217+ for i := 0 ; i < n; i++ {
218+ d[i] = min (d[i], d[i+n])
219+ }
220+ 221+ ans := make ([]int , len (queries))
222+ for i , query := range queries {
223+ if d[query] >= n {
224+ ans[i] = -1
225+ } else {
226+ ans[i] = d[query]
227+ }
228+ }
229+ return ans
230+ }
231+ ```
98232
233+ #### TypeScript
234+ 235+ ``` ts
236+ function solveQueries(nums : number [], queries : number []): number [] {
237+ const = nums .length ;
238+ const = n * 2 ;
239+ const : number [] = Array (m ).fill (m );
240+ 241+ const = new Map <number , number >();
242+ for (let i = 0 ; i < m ; i ++ ) {
243+ const = nums [i % n ];
244+ if (left .has (x )) {
245+ d [i ] = Math .min (d [i ], i - left .get (x )! );
246+ }
247+ left .set (x , i );
248+ }
249+ 250+ const = new Map <number , number >();
251+ for (let i = m - 1 ; i >= 0 ; i -- ) {
252+ const = nums [i % n ];
253+ if (right .has (x )) {
254+ d [i ] = Math .min (d [i ], right .get (x )! - i );
255+ }
256+ right .set (x , i );
257+ }
258+ 259+ for (let i = 0 ; i < n ; i ++ ) {
260+ d [i ] = Math .min (d [i ], d [i + n ]);
261+ }
262+ 263+ return queries .map (query => (d [query ] >= n ? - 1 : d [query ]));
264+ }
99265```
100266
101267<!-- tabs:end -->
0 commit comments