feat: add solutions to lc problem: No.2613

No.2613.Beautiful Pairs

Author: yanglbme

solution/1000-1099/1040.Moving Stones Until Consecutive II/README.md

@@ -63,6 +63,16 @@
 
 **方法一：排序 + 分类讨论 + 双指针**
 
+我们先对数组 `stones` 进行升序排序，接下来分别考虑最大移动次数 $mx$ 和最小移动次数 $mi$。
+
+对于最大移动次数 $mx$：
+
+由于我们每一次只能选择将端点石子移动到未占用且不是端点石子的位置，如果我们选择 `stones[0]` 作为第一次移动的端点石子，那么从 `stones[0]` 到 `stones[1]` 之间的所有未占用的位置都会被跳过，我们可以选择移动到最近的且未占用的位置，接下来每一次都将最左端的石子移动到最近的且未占用的位置，那么最多可以移动的次数为 $stones[n - 1] - stones[1] + 1 - (n - 1)$；同理，如果我们选择 `stones[n - 1]` 作为第一次移动的端点石子，那么最多可以移动的次数为 $stones[n - 2] - stones[0] + 1 - (n - 1)$。取两者的最大值即为最大移动次数 $mx$。
+
+对于最小移动次数 $mi$：
+
+我们用双指针 $i$ 和 $j$ 标识一个窗口的左右端点，若窗口内的位置数 $stones[j] - stones[i] + 1 \gt n$ 时，我们需要缩小窗口，即指针 $i$ 向右移动。如果此时窗口中有连续的 $n-1$ 个石子，即满足 $j - i + 1 = n - 1$ 且 $stones[j] - stones[i] + 1 = n - 1$，那么最少需要移动的次数为 $2$；否则，我们用 $n$ 减去窗口内的石子数，可以得到最少需要移动的次数，即 $n - (j - i + 1)$。取所有情况的最小值即为最小移动次数 $mi$。
+
 时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为数组 `stones` 的长度。
 
 <!-- tabs:start -->

solution/2600-2699/2613.Beautiful Pairs/README.md

@@ -48,34 +48,367 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：排序 + 分治**
+
+本题相当于找出平面中两个点，使得它们的曼哈顿距离最小，如果有多个点满足条件，则返回下标字典序最小的点。
+
+我们先处理重复点的情况，找出每个点对应的下标列表，如果某个点的下标列表长度大于 $1$，那么它的前两个下标可作为候选答案，我们找出最小的下标对即可。
+
+如果没有重复点，我们将所有点按照 $x$ 坐标排序，然后分治求解。
+
+对于每个区间 $[l, r]$，我们先求出 $x$ 坐标的中位数 $m$，然后递归求解左右两个区间，分别得到 $d_1, (pi_1, pj_1)$ 和 $d_2, (pi_2, pj_2)$，其中 $d_1$ 和 $d_2$ 分别表示左右两个区间的最小曼哈顿距离，而 $(pi_1, pj_1)$ 和 $(pi_2, pj_2)$ 分别表示左右两个区间的最小曼哈顿距离的两个点的下标。我们取 $d_1$ 和 $d_2$ 中较小的一个，如果 $d_1 = d_2$，则取下标字典序较小的一个，将其作为当前区间的最小曼哈顿距离，同时将对应的两个点的下标作为答案。
+
+以上考虑的是两个点位于同一侧的情况，如果两个点位于不同侧，那么我们以中间点，即下标为 $m = \lfloor (l + r) / 2 \rfloor$ 的点为标准，划分出一个新的区域，区域的范围为中间点向左右两侧分别扩展 $d_1$ 的范围。然后我们将这些范围内的点按照 $y$ 坐标排序，然后遍历排序后的每个点对，如果两个点的 $y$ 坐标之差大于当前的最小曼哈顿距离，那么后面的点对都不用考虑了，因为它们的 $y$ 坐标之差更大，所以曼哈顿距离更大，不会比当前的最小曼哈顿距离更小。否则，我们更新最小曼哈顿距离，同时更新答案。
+
+最后，我们返回答案即可。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def beautifulPair(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        def dist(x1: int, y1: int, x2: int, y2: int) -> int:
+            return abs(x1 - x2) + abs(y1 - y2)
+
+        def dfs(l: int, r: int):
+            if l >= r:
+                return inf, -1, -1
+            m = (l + r) >> 1
+            x = points[m][0]
+            d1, pi1, pj1 = dfs(l, m)
+            d2, pi2, pj2 = dfs(m + 1, r)
+            if d1 > d2 or (d1 == d2 and (pi1 > pi2 or (pi1 == pi2 and pj1 > pj2))):
+                d1, pi1, pj1 = d2, pi2, pj2
+            t = [p for p in points[l: r + 1] if abs(p[0] - x) <= d1]
+            t.sort(key=lambda x: x[1])
+            for i in range(len(t)):
+                for j in range(i + 1, len(t)):
+                    if t[j][1] - t[i][1] > d1:
+                        break
+                    pi, pj = sorted([t[i][2], t[j][2]])
+                    d = dist(t[i][0], t[i][1], t[j][0], t[j][1])
+                    if d < d1 or (d == d1 and (pi < pi1 or (pi == pi1 and pj < pj1))):
+                        d1, pi1, pj1 = d, pi, pj
+            return d1, pi1, pj1
+
+        pl = defaultdict(list)
+        for i, (x, y) in enumerate(zip(nums1, nums2)):
+            pl[(x, y)].append(i)
+        points = []
+        for i, (x, y) in enumerate(zip(nums1, nums2)):
+            if len(pl[(x, y)]) > 1:
+                return [i, pl[(x, y)][1]]
+            points.append((x, y, i))
+        points.sort()
+        _, pi, pj = dfs(0, len(points) - 1)
+        return [pi, pj]
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    private List<int[]> points = new ArrayList<>();
+
+    public int[] beautifulPair(int[] nums1, int[] nums2) {
+        int n = nums1.length;
+        Map<Long, List<Integer>> pl = new HashMap<>();
+        for (int i = 0; i < n; ++i) {
+            long z = f(nums1[i], nums2[i]);
+            pl.computeIfAbsent(z, k -> new ArrayList<>()).add(i);
+        }
+        for (int i = 0; i < n; ++i) {
+            long z = f(nums1[i], nums2[i]);
+            if (pl.get(z).size() > 1) {
+                return new int[]{i, pl.get(z).get(1)};
+            }
+            points.add(new int[]{nums1[i], nums2[i], i});
+        }
+        points.sort((a, b) -> a[0] - b[0]);
+        int[] ans = dfs(0, points.size() - 1);
+        return new int[]{ans[1], ans[2]};
+    }
+
+    private long f(int x, int y) {
+        return x * 100000L + y;
+    }
+
+    private int dist(int x1, int y1, int x2, int y2) {
+        return Math.abs(x1 - x2) + Math.abs(y1 - y2);
+    }
+
+    private int[] dfs(int l, int r) {
+        if (l >= r) {
+            return new int[]{1 << 30, -1, -1};
+        }
+        int m = (l + r) >> 1;
+        int x = points.get(m)[0];
+        int[] t1 = dfs(l, m);
+        int[] t2 = dfs(m + 1, r);
+        if (t1[0] > t2[0] || (t1[0] == t2[0] && (t1[1] > t2[1] || (t1[1] == t2[1] && t1[2] > t2[2])))) {
+            t1 = t2;
+        }
+        List<int[]> t = new ArrayList<>();
+        for (int i = l; i <= r; ++i) {
+            if (Math.abs(points.get(i)[0] - x) <= t1[0]) {
+                t.add(points.get(i));
+            }
+        }
+        t.sort((a, b) -> a[1] - b[1]);
+        for (int i = 0; i < t.size(); ++i) {
+            for (int j = i + 1; j < t.size(); ++j) {
+                if (t.get(j)[1] - t.get(i)[1] > t1[0]) {
+                    break;
+                }
+                int pi = Math.min(t.get(i)[2], t.get(j)[2]);
+                int pj = Math.max(t.get(i)[2], t.get(j)[2]);
+                int d = dist(t.get(i)[0], t.get(i)[1], t.get(j)[0], t.get(j)[1]);
+                if (d < t1[0] || (d == t1[0] && (pi < t1[1] || (pi == t1[1] && pj < t1[2])))) {
+                    t1 = new int[]{d, pi, pj};
+                }
+            }
+        }
+        return t1;
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    vector<int> beautifulPair(vector<int>& nums1, vector<int>& nums2) {
+        int n = nums1.size();
+        unordered_map<long long, vector<int>> pl;
+        for (int i = 0; i < n; ++i) {
+            pl[f(nums1[i], nums2[i])].push_back(i);
+        }
+        vector<tuple<int, int, int>> points;
+        for (int i = 0; i < n; ++i) {
+            long long z = f(nums1[i], nums2[i]);
+            if (pl[z].size() > 1) {
+                return {i, pl[z][1]};
+            }
+            points.emplace_back(nums1[i], nums2[i], i);
+        }
+
+        function<tuple<int, int, int>(int, int)> dfs = [&](int l, int r) -> tuple<int, int, int> {
+            if (l >= r) {
+                return {1 << 30, -1, -1};
+            }
+            int m = (l + r) >> 1;
+            int x = get<0>(points[m]);
+            auto t1 = dfs(l, m);
+            auto t2 = dfs(m + 1, r);
+            if (get<0>(t1) > get<0>(t2) || (get<0>(t1) == get<0>(t2) && (get<1>(t1) > get<1>(t2) || (get<1>(t1) == get<1>(t2) && get<2>(t1) > get<2>(t2))))) {
+                swap(t1, t2);
+            }
+            vector<tuple<int, int, int>> t;
+            for (int i = l; i <= r; ++i) {
+                if (abs(get<0>(points[i]) - x) <= get<0>(t1)) {
+                    t.emplace_back(points[i]);
+                }
+            }
+            sort(t.begin(), t.end(), [](const tuple<int, int, int>& a, const tuple<int, int, int>& b) {
+                return get<1>(a) < get<1>(b);
+            });
+            for (int i = 0; i < t.size(); ++i) {
+                for (int j = i + 1; j < t.size(); ++j) {
+                    if (get<1>(t[j]) - get<1>(t[i]) > get<0>(t1)) {
+                        break;
+                    }
+                    int pi = min(get<2>(t[i]), get<2>(t[j]));
+                    int pj = max(get<2>(t[i]), get<2>(t[j]));
+                    int d = dist(get<0>(t[i]), get<1>(t[i]), get<0>(t[j]), get<1>(t[j]));
+                    if (d < get<0>(t1) || (d == get<0>(t1) && (pi < get<1>(t1) || (pi == get<1>(t1) && pj < get<2>(t1))))) {
+                        t1 = {d, pi, pj};
+                    }
+                }
+            }
+            return t1;
+        };
+
+        sort(points.begin(), points.end());
+        auto [_, pi, pj] = dfs(0, points.size() - 1);
+        return {pi, pj};
+    }
+
+    long long f(int x, int y) {
+        return x * 100000LL + y;
+    }
+
+    int dist(int x1, int y1, int x2, int y2) {
+        return abs(x1 - x2) + abs(y1 - y2);
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func beautifulPair(nums1 []int, nums2 []int) []int {
+	n := len(nums1)
+	pl := map[[2]int][]int{}
+	for i := 0; i < n; i++ {
+		k := [2]int{nums1[i], nums2[i]}
+		pl[k] = append(pl[k], i)
+	}
+	points := [][3]int{}
+	for i := 0; i < n; i++ {
+		k := [2]int{nums2[i], nums1[i]}
+		if len(pl[k]) > 1 {
+			return []int{pl[k][0], pl[k][1]}
+		}
+		points = append(points, [3]int{nums1[i], nums2[i], i})
+	}
+	sort.Slice(points, func(i, j int) bool { return points[i][0] < points[j][0] })
+
+	var dfs func(l, r int) [3]int
+	dfs = func(l, r int) [3]int {
+		if l >= r {
+			return [3]int{1 << 30, -1, -1}
+		}
+		m := (l + r) >> 1
+		x := points[m][0]
+		t1 := dfs(l, m)
+		t2 := dfs(m+1, r)
+		if t1[0] > t2[0] || (t1[0] == t2[0] && (t1[1] > t2[1] || (t1[1] == t2[1] && t1[2] > t2[2]))) {
+			t1 = t2
+		}
+		t := [][3]int{}
+		for i := l; i <= r; i++ {
+			if abs(points[i][0]-x) <= t1[0] {
+				t = append(t, points[i])
+			}
+		}
+		sort.Slice(t, func(i, j int) bool { return t[i][1] < t[j][1] })
+		for i := 0; i < len(t); i++ {
+			for j := i + 1; j < len(t); j++ {
+				if t[j][1]-t[i][1] > t1[0] {
+					break
+				}
+				pi := min(t[i][2], t[j][2])
+				pj := max(t[i][2], t[j][2])
+				d := dist(t[i][0], t[i][1], t[j][0], t[j][1])
+				if d < t1[0] || (d == t1[0] && (pi < t1[1] || (pi == t1[1] && pj < t1[2]))) {
+					t1 = [3]int{d, pi, pj}
+				}
+			}
+		}
+		return t1
+	}
+	ans := dfs(0, n-1)
+	return []int{ans[1], ans[2]}
+}
+
+func dist(x1, y1, x2, y2 int) int {
+	return abs(x1-x2) + abs(y1-y2)
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}
+```
 
+### **TypeScript**
+
+```ts
+function beautifulPair(nums1: number[], nums2: number[]): number[] {
+    const pl: Map<number, number[]> = new Map();
+    const n = nums1.length;
+    for (let i = 0; i < n; ++i) {
+        const z = f(nums1[i], nums2[i]);
+        if (!pl.has(z)) {
+            pl.set(z, []);
+        }
+        pl.get(z)!.push(i);
+    }
+    const points: number[][] = [];
+    for (let i = 0; i < n; ++i) {
+        const z = f(nums1[i], nums2[i]);
+        if (pl.get(z)!.length > 1) {
+            return [i, pl.get(z)![1]];
+        }
+        points.push([nums1[i], nums2[i], i]);
+    }
+    points.sort((a, b) => a[0] - b[0]);
+
+    const dfs = (l: number, r: number): number[] => {
+        if (l >= r) {
+            return [1 << 30, -1, -1];
+        }
+        const m = (l + r) >> 1;
+        const x = points[m][0];
+        let t1 = dfs(l, m);
+        let t2 = dfs(m + 1, r);
+        if (
+            t1[0] > t2[0] ||
+            (t1[0] == t2[0] &&
+                (t1[1] > t2[1] || (t1[1] == t2[1] && t1[2] > t2[2])))
+        ) {
+            t1 = t2;
+        }
+        const t: number[][] = [];
+        for (let i = l; i <= r; ++i) {
+            if (Math.abs(points[i][0] - x) <= t1[0]) {
+                t.push(points[i]);
+            }
+        }
+        t.sort((a, b) => a[1] - b[1]);
+        for (let i = 0; i < t.length; ++i) {
+            for (let j = i + 1; j < t.length; ++j) {
+                if (t[j][1] - t[i][1] > t1[0]) {
+                    break;
+                }
+                const pi = Math.min(t[i][2], t[j][2]);
+                const pj = Math.max(t[i][2], t[j][2]);
+                const d = dist(t[i][0], t[i][1], t[j][0], t[j][1]);
+                if (
+                    d < t1[0] ||
+                    (d == t1[0] && (pi < t1[1] || (pi == t1[1] && pj < t1[2])))
+                ) {
+                    t1 = [d, pi, pj];
+                }
+            }
+        }
+        return t1;
+    };
+    return dfs(0, n - 1).slice(1);
+}
+
+function dist(x1: number, y1: number, x2: number, y2: number): number {
+    return Math.abs(x1 - x2) + Math.abs(y1 - y2);
+}
+
+function f(x: number, y: number): number {
+    return x * 100000 + y;
+}
 ```
 
 ### **...**