feat: add solutions to lc problem: No.2001

No.2001.Number of Pairs of Interchangeable Rectangles

Author: yanglbme

solution/2000-2099/2001.Number of Pairs of Interchangeable Rectangles/README.md

@@ -51,22 +51,106 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：数学 + 哈希表**
+
+为了能够唯一表示矩形，我们需要将矩形的宽高比化简为最简分数。因此，我们可以求出每个矩形的宽高比的最大公约数，然后将宽高比化简为最简分数。接下来，我们使用哈希表统计每个最简分数的矩形数量，然后计算每个最简分数的矩形数量的组合数，即可得到答案。
+
+时间复杂度 $O(n \log M)$，空间复杂度 $O(n)$。其中 $n$ 和 $M$ 分别是矩形的数量和矩形的最大边长。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def interchangeableRectangles(self, rectangles: List[List[int]]) -> int:
+        ans = 0
+        cnt = Counter()
+        for w, h in rectangles:
+            g = gcd(w, h)
+            w, h = w // g, h // g
+            ans += cnt[(w, h)]
+            cnt[(w, h)] += 1
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public long interchangeableRectangles(int[][] rectangles) {
+        long ans = 0;
+        int n = rectangles.length + 1;
+        Map<Long, Integer> cnt = new HashMap<>();
+        for (var e : rectangles) {
+            int w = e[0], h = e[1];
+            int g = gcd(w, h);
+            w /= g;
+            h /= g;
+            long x = (long) w * n + h;
+            ans += cnt.getOrDefault(x, 0);
+            cnt.merge(x, 1, Integer::sum);
+        }
+        return ans;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    long long interchangeableRectangles(vector<vector<int>>& rectangles) {
+        long long ans = 0;
+        int n = rectangles.size();
+        unordered_map<long long, int> cnt;
+        for (auto& e : rectangles) {
+            int w = e[0], h = e[1];
+            int g = gcd(w, h);
+            w /= g;
+            h /= g;
+            long long x = 1ll * w * (n + 1) + h;
+            ans += cnt[x];
+            cnt[x]++;
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func interchangeableRectangles(rectangles [][]int) int64 {
+	ans := 0
+	n := len(rectangles)
+	cnt := map[int]int{}
+	for _, e := range rectangles {
+		w, h := e[0], e[1]
+		g := gcd(w, h)
+		w, h = w/g, h/g
+		x := w*(n+1) + h
+		ans += cnt[x]
+		cnt[x]++
+	}
+	return int64(ans)
+}
+
+func gcd(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return gcd(b, a%b)
+}
 ```
 
 ### **...**

solution/2000-2099/2001.Number of Pairs of Interchangeable Rectangles/README_EN.md

@@ -50,13 +50,91 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def interchangeableRectangles(self, rectangles: List[List[int]]) -> int:
+        ans = 0
+        cnt = Counter()
+        for w, h in rectangles:
+            g = gcd(w, h)
+            w, h = w // g, h // g
+            ans += cnt[(w, h)]
+            cnt[(w, h)] += 1
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public long interchangeableRectangles(int[][] rectangles) {
+        long ans = 0;
+        int n = rectangles.length + 1;
+        Map<Long, Integer> cnt = new HashMap<>();
+        for (var e : rectangles) {
+            int w = e[0], h = e[1];
+            int g = gcd(w, h);
+            w /= g;
+            h /= g;
+            long x = (long) w * n + h;
+            ans += cnt.getOrDefault(x, 0);
+            cnt.merge(x, 1, Integer::sum);
+        }
+        return ans;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    long long interchangeableRectangles(vector<vector<int>>& rectangles) {
+        long long ans = 0;
+        int n = rectangles.size();
+        unordered_map<long long, int> cnt;
+        for (auto& e : rectangles) {
+            int w = e[0], h = e[1];
+            int g = gcd(w, h);
+            w /= g;
+            h /= g;
+            long long x = 1ll * w * (n + 1) + h;
+            ans += cnt[x];
+            cnt[x]++;
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func interchangeableRectangles(rectangles [][]int) int64 {
+	ans := 0
+	n := len(rectangles)
+	cnt := map[int]int{}
+	for _, e := range rectangles {
+		w, h := e[0], e[1]
+		g := gcd(w, h)
+		w, h = w/g, h/g
+		x := w*(n+1) + h
+		ans += cnt[x]
+		cnt[x]++
+	}
+	return int64(ans)
+}
+
+func gcd(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return gcd(b, a%b)
+}
 ```
 
 ### **...**

solution/2000-2099/2001.Number of Pairs of Interchangeable Rectangles/Solution.cpp

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    long long interchangeableRectangles(vector<vector<int>>& rectangles) {
+        long long ans = 0;
+        int n = rectangles.size();
+        unordered_map<long long, int> cnt;
+        for (auto& e : rectangles) {
+            int w = e[0], h = e[1];
+            int g = gcd(w, h);
+            w /= g;
+            h /= g;
+            long long x = 1ll * w * (n + 1) + h;
+            ans += cnt[x];
+            cnt[x]++;
+        }
+        return ans;
+    }
+};

solution/2000-2099/2001.Number of Pairs of Interchangeable Rectangles/Solution.go

@@ -0,0 +1,21 @@
+func interchangeableRectangles(rectangles [][]int) int64 {
+	ans := 0
+	n := len(rectangles)
+	cnt := map[int]int{}
+	for _, e := range rectangles {
+		w, h := e[0], e[1]
+		g := gcd(w, h)
+		w, h = w/g, h/g
+		x := w*(n+1) + h
+		ans += cnt[x]
+		cnt[x]++
+	}
+	return int64(ans)
+}
+
+func gcd(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return gcd(b, a%b)
+}

solution/2000-2099/2001.Number of Pairs of Interchangeable Rectangles/Solution.java

@@ -0,0 +1,21 @@
+class Solution {
+    public long interchangeableRectangles(int[][] rectangles) {
+        long ans = 0;
+        int n = rectangles.length + 1;
+        Map<Long, Integer> cnt = new HashMap<>();
+        for (var e : rectangles) {
+            int w = e[0], h = e[1];
+            int g = gcd(w, h);
+            w /= g;
+            h /= g;
+            long x = (long) w * n + h;
+            ans += cnt.getOrDefault(x, 0);
+            cnt.merge(x, 1, Integer::sum);
+        }
+        return ans;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}

solution/2000-2099/2001.Number of Pairs of Interchangeable Rectangles/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def interchangeableRectangles(self, rectangles: List[List[int]]) -> int:
+        ans = 0
+        cnt = Counter()
+        for w, h in rectangles:
+            g = gcd(w, h)
+            w, h = w // g, h // g
+            ans += cnt[(w, h)]
+            cnt[(w, h)] += 1
+        return ans