chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2026-04-11-3741-Minimum-Distance-Between-Three-Equal-Elements-II/explanation.md

@@ -0,0 +1,31 @@
+# Minimum Distance Between Three Equal Elements II (Medium)
+
+**Problem ID:** 3741  
+**Date:** 2026-04-11  
+**Link:** https://leetcode.com/problems/minimum-distance-between-three-equal-elements-ii/
+
+## Approach
+
+To solve the problem of finding the minimum distance between three equal elements in an array, we can adopt the following approach:
+
+### Main Idea
+The goal is to find three distinct indices \(i\), \(j\), and \(k\) such that the elements at these indices are equal, and we want to minimize the distance defined as \( \text{abs}(i - j) + \text{abs}(j - k) + \text{abs}(k - i) \). This distance can be simplified to \( \text{max}(i, j, k) - \text{min}(i, j, k) \) multiplied by 2, since the absolute differences can be rearranged.
+
+### Approach
+1. **Index Tracking**: Use a dictionary to map each unique number in the array to a list of its indices. This allows us to quickly access the positions of any number.
+
+2. **Distance Calculation**: For each number that appears at least three times (since we need three indices), retrieve its list of indices. We can then calculate the distance for every triplet of indices using a sliding window approach:
+   - For a list of indices, iterate through the list and for each triplet of indices \( (i, j, k) \), compute the distance using the formula mentioned above.
+   - Since the indices are sorted, we can efficiently compute the distance by just considering the first three indices in the list and sliding through the list.
+
+3. **Minimization**: Track the minimum distance encountered during the iteration. If no valid triplet is found, return -1.
+
+### Data Structures
+- A dictionary (or hashmap) to store lists of indices for each unique number.
+- A variable to keep track of the minimum distance found.
+
+### Complexity
+- **Time Complexity**: The overall time complexity is \(O(n)\) for traversing the array to populate the dictionary and \(O(k)\) for processing each unique number, where \(k\) is the number of unique elements. In the worst case, this is still linear relative to the size of the input.
+- **Space Complexity**: The space complexity is \(O(n)\) in the worst case, where all elements are unique and stored in the dictionary.
+
+This approach is efficient and leverages the properties of indices and distances to find the solution without the need for a brute-force search, making it suitable for the problem's constraints.

Medium/2026-04-11-3741-Minimum-Distance-Between-Three-Equal-Elements-II/solution.java

@@ -0,0 +1,32 @@
+import java.util.*;
+
+public class Solution {
+    public int minimumDistance(int[] nums) {
+        Map<Integer, List<Integer>> indexMap = new HashMap<>();
+        
+        for (int i = 0; i < nums.length; i++) {
+            indexMap.computeIfAbsent(nums[i], k -> new ArrayList<>()).add(i);
+        }
+        
+        int minDistance = Integer.MAX_VALUE;
+        boolean found = false;
+
+        for (List<Integer> indices : indexMap.values()) {
+            if (indices.size() >= 3) {
+                for (int i = 0; i < indices.size(); i++) {
+                    for (int j = i + 1; j < indices.size(); j++) {
+                        for (int k = j + 1; k < indices.size(); k++) {
+                            int distance = Math.abs(indices.get(i) - indices.get(j)) +
+                                           Math.abs(indices.get(j) - indices.get(k)) +
+                                           Math.abs(indices.get(k) - indices.get(i));
+                            minDistance = Math.min(minDistance, distance);
+                            found = true;
+                        }
+                    }
+                }
+            }
+        }
+        
+        return found ? minDistance : -1;
+    }
+}

Medium/2026-04-11-3741-Minimum-Distance-Between-Three-Equal-Elements-II/solution.js

@@ -0,0 +1,28 @@
+var minimumDistance = function(nums) {
+    const indices = new Map();
+    let minDistance = Infinity;
+
+    for (let i = 0; i < nums.length; i++) {
+        if (!indices.has(nums[i])) {
+            indices.set(nums[i], []);
+        }
+        indices.get(nums[i]).push(i);
+    }
+
+    for (const indexList of indices.values()) {
+        if (indexList.length < 3) continue;
+
+        for (let i = 0; i < indexList.length - 2; i++) {
+            for (let j = i + 1; j < indexList.length - 1; j++) {
+                for (let k = j + 1; k < indexList.length; k++) {
+                    const distance = Math.abs(indexList[i] - indexList[j]) +
+                                     Math.abs(indexList[j] - indexList[k]) +
+                                     Math.abs(indexList[k] - indexList[i]);
+                    minDistance = Math.min(minDistance, distance);
+                }
+            }
+        }
+    }
+
+    return minDistance === Infinity ? -1 : minDistance;
+};

Medium/2026-04-11-3741-Minimum-Distance-Between-Three-Equal-Elements-II/solution.py

@@ -0,0 +1,20 @@
+class Solution:
+    def minimumDistance(self, nums: List[int]) -> int:
+        from collections import defaultdict
+        indices = defaultdict(list)
+        
+        for i, num in enumerate(nums):
+            indices[num].append(i)
+        
+        min_distance = float('inf')
+        
+        for idx_list in indices.values():
+            if len(idx_list) < 3:
+                continue
+            for i in range(len(idx_list) - 2):
+                for j in range(i + 1, len(idx_list) - 1):
+                    for k in range(j + 1, len(idx_list)):
+                        dist = abs(idx_list[i] - idx_list[j]) + abs(idx_list[j] - idx_list[k]) + abs(idx_list[k] - idx_list[i])
+                        min_distance = min(min_distance, dist)
+        
+        return min_distance if min_distance != float('inf') else -1

README.md

@@ -420,3 +420,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-08 — [XOR After Range Multiplication Queries I](https://leetcode.com/problems/xor-after-range-multiplication-queries-i/) (Medium) → `Medium/2026-04-08-3653-XOR-After-Range-Multiplication-Queries-I`
 - 2026-04-09 — [XOR After Range Multiplication Queries II](https://leetcode.com/problems/xor-after-range-multiplication-queries-ii/) (Hard) → `Hard/2026-04-09-3655-XOR-After-Range-Multiplication-Queries-II`
 - 2026-04-10 — [Minimum Distance Between Three Equal Elements I](https://leetcode.com/problems/minimum-distance-between-three-equal-elements-i/) (Easy) → `Easy/2026-04-10-3740-Minimum-Distance-Between-Three-Equal-Elements-I`
+- 2026-04-11 — [Minimum Distance Between Three Equal Elements II](https://leetcode.com/problems/minimum-distance-between-three-equal-elements-ii/) (Medium) → `Medium/2026-04-11-3741-Minimum-Distance-Between-Three-Equal-Elements-II`