feat: add solutions to lc problem: No.0149

No.0149.Max Points on a Line

Author: yanglbme

solution/0100-0199/0149.Max Points on a Line/README.md

@@ -39,11 +39,17 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-在平面上确定一个点 `points[i]`，其他点与 `point[i]` 可以求得一个斜率，斜率相同的点意味着它们与 `points[i]` 在同一条直线上。
+**方法一：暴力枚举**
 
-所以可以用哈希表作为计数器，其中斜率作为 key，然后累计当前点相同的斜率出现的次数。斜率可能是小数，我们可以用分数形式表示，先求分子分母的最大公约数，然后约分，最后将“分子.分母” 作为 key 即可。
+我们可以枚举任意两个点 $(x_1, y_1), (x_2, y_2)$，把这两个点连成一条直线，那么此时这条直线上的点的个数就是 2，接下来我们再枚举其他点 $(x_3, y_3)$，判断它们是否在同一条直线上，如果在，那么直线上的点的个数就加 1，如果不在，那么直线上的点的个数不变。找出所有直线上的点的个数的最大值，即为答案。
 
-需要注意，如果平面上有和当前点重叠的点，如果进行约分，会出现除 0 的情况，那么我们单独用一个变量 duplicate 统计重复点的个数，重复点一定是过当前点的直线的。
+时间复杂度 $O(n^3)$，空间复杂度 $O(1)$。其中 $n$ 是数组 `points` 的长度。
+
+**方法二：枚举 + 哈希表**
+
+我们可以枚举一个点 $(x_1, y_1)$，把其他所有点 $(x_2, y_2)$ 与 $(x_1, y_1)$ 连成的直线的斜率存入哈希表中，斜率相同的点在同一条直线上，哈希表的键为斜率，值为直线上的点的个数。找出哈希表中的最大值，即为答案。为了避免精度问题，我们可以将斜率 $\frac{y_2 - y_1}{x_2 - x_1}$ 进行约分，约分的方法是求最大公约数，然后分子分母同时除以最大公约数，将求得的分子分母作为哈希表的键。
+
+时间复杂度 $O(n^2 \times \log m)$，空间复杂度 $O(n)$。其中 $n$ 和 $m$ 分别是数组 `points` 的长度和数组 `points` 所有横纵坐标差的最大值。
 
 <!-- tabs:start -->
 
@@ -54,30 +60,41 @@
 ```python
 class Solution:
     def maxPoints(self, points: List[List[int]]) -> int:
-        def gcd(a, b) -> int:
+        n = len(points)
+        ans = 1
+        for i in range(n):
+            x1, y1 = points[i]
+            for j in range(i + 1, n):
+                x2, y2 = points[j]
+                cnt = 2
+                for k in range(j + 1, n):
+                    x3, y3 = points[k]
+                    a = (y2 - y1) * (x3 - x1)
+                    b = (y3 - y1) * (x2 - x1)
+                    cnt += a == b
+                ans = max(ans, cnt)
+        return ans
+```
+
+```python
+class Solution:
+    def maxPoints(self, points: List[List[int]]) -> int:
+        def gcd(a, b):
             return a if b == 0 else gcd(b, a % b)
 
         n = len(points)
-        if n < 3:
-            return n
-        res = 0
-        for i in range(n - 1):
-            counter = Counter()
-            t_max = duplicate = 0
+        ans = 1
+        for i in range(n):
+            x1, y1 = points[i]
+            cnt = Counter()
             for j in range(i + 1, n):
-                delta_x = points[i][0] - points[j][0]
-                delta_y = points[i][1] - points[j][1]
-                if delta_x == 0 and delta_y == 0:
-                    duplicate += 1
-                    continue
-                g = gcd(delta_x, delta_y)
-                d_x = delta_x // g
-                d_y = delta_y // g
-                key = f'{d_x}.{d_y}'
-                counter[key] += 1
-                t_max = max(t_max, counter[key])
-            res = max(res, t_max + duplicate + 1)
-        return res
+                x2, y2 = points[j]
+                dx, dy = x2 - x1, y2 - y1
+                g = gcd(dx, dy)
+                k = (dx // g, dy // g)
+                cnt[k] += 1
+                ans = max(ans, cnt[k] + 1)
+        return ans
 ```
 
 ### **Java**
@@ -88,31 +105,46 @@ class Solution:
 class Solution {
     public int maxPoints(int[][] points) {
         int n = points.length;
-        if (n < 3) {
-            return n;
-        }
-        int res = 0;
-        for (int i = 0; i < n - 1; ++i) {
-            Map<String, Integer> kCounter = new HashMap<>();
-            int max = 0;
-            int duplicate = 0;
+        int ans = 1;
+        for (int i = 0; i < n; ++i) {
+            int x1 = points[i][0], y1 = points[i][1];
             for (int j = i + 1; j < n; ++j) {
-                int deltaX = points[i][0] - points[j][0];
-                int deltaY = points[i][1] - points[j][1];
-                if (deltaX == 0 && deltaY == 0) {
-                    ++duplicate;
-                    continue;
+                int x2 = points[j][0], y2 = points[j][1];
+                int cnt = 2;
+                for (int k = j + 1; k < n; ++k) {
+                    int x3 = points[k][0], y3 = points[k][1];
+                    int a = (y2 - y1) * (x3 - x1);
+                    int b = (y3 - y1) * (x2 - x1);
+                    if (a == b) {
+                        ++cnt;
+                    }
                 }
-                int gcd = gcd(deltaX, deltaY);
-                int dX = deltaX / gcd;
-                int dY = deltaY / gcd;
-                String key = dX + "." + dY;
-                kCounter.put(key, kCounter.getOrDefault(key, 0) + 1);
-                max = Math.max(max, kCounter.get(key));
+                ans = Math.max(ans, cnt);
             }
-            res = Math.max(res, max + duplicate + 1);
         }
-        return res;
+        return ans;
+    }
+}
+```
+
+```java
+class Solution {
+    public int maxPoints(int[][] points) {
+        int n = points.length;
+        int ans = 1;
+        for (int i = 0; i < n; ++i) {
+            int x1 = points[i][0], y1 = points[i][1];
+            Map<String, Integer> cnt = new HashMap<>();
+            for (int j = i + 1; j < n; ++j) {
+                int x2 = points[j][0], y2 = points[j][1];
+                int dx = x2 - x1, dy = y2 - y1;
+                int g = gcd(dx, dy);
+                String k = (dx / g) + "." + (dy / g);
+                cnt.put(k, cnt.getOrDefault(k, 0) + 1);
+                ans = Math.max(ans, cnt.get(k) + 1);
+            }
+        }
+        return ans;
     }
 
     private int gcd(int a, int b) {
@@ -121,45 +153,144 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int maxPoints(vector<vector<int>>& points) {
+        int n = points.size();
+        int ans = 1;
+        for (int i = 0; i < n; ++i) {
+            int x1 = points[i][0], y1 = points[i][1];
+            for (int j = i + 1; j < n; ++j) {
+                int x2 = points[j][0], y2 = points[j][1];
+                int cnt = 2;
+                for (int k = j + 1; k < n; ++k) {
+                    int x3 = points[k][0], y3 = points[k][1];
+                    int a = (y2 - y1) * (x3 - x1);
+                    int b = (y3 - y1) * (x2 - x1);
+                    cnt += a == b;
+                }
+                ans = max(ans, cnt);
+            }
+        }
+        return ans;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+    int maxPoints(vector<vector<int>>& points) {
+        int n = points.size();
+        int ans = 1;
+        for (int i = 0; i < n; ++i) {
+            int x1 = points[i][0], y1 = points[i][1];
+            unordered_map<string, int> cnt;
+            for (int j = i + 1; j < n; ++j) {
+                int x2 = points[j][0], y2 = points[j][1];
+                int dx = x2 - x1, dy = y2 - y1;
+                int g = gcd(dx, dy);
+                string k = to_string(dx / g) + "." + to_string(dy / g);
+                cnt[k]++;
+                ans = max(ans, cnt[k] + 1);
+            }
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
 func maxPoints(points [][]int) int {
-	type pair struct {
-		first  int
-		second int
-	}
 	n := len(points)
-	if n <= 2 {
-		return n
+	ans := 1
+	for i := 0; i < n; i++ {
+		x1, y1 := points[i][0], points[i][1]
+		for j := i + 1; j < n; j++ {
+			x2, y2 := points[j][0], points[j][1]
+			cnt := 2
+			for k := j + 1; k < n; k++ {
+				x3, y3 := points[k][0], points[k][1]
+				a := (y2 - y1) * (x3 - x1)
+				b := (y3 - y1) * (x2 - x1)
+				if a == b {
+					cnt++
+				}
+			}
+			if ans < cnt {
+				ans = cnt
+			}
+		}
 	}
-	ans := 0
-	for i := 0; i < n-1; i++ {
-		freq := make(map[pair]int)
+	return ans
+}
+```
+
+```go
+func maxPoints(points [][]int) int {
+	n := len(points)
+	ans := 1
+	type pair struct{ x, y int }
+	for i := 0; i < n; i++ {
+		x1, y1 := points[i][0], points[i][1]
+		cnt := map[pair]int{}
 		for j := i + 1; j < n; j++ {
-			x1, y1, x2, y2 := points[i][0], points[i][1], points[j][0], points[j][1]
+			x2, y2 := points[j][0], points[j][1]
 			dx, dy := x2-x1, y2-y1
 			g := gcd(dx, dy)
-			p := pair{dx / g, dy / g}
-			freq[p]++
-			ans = max(ans, freq[p]+1)
+			k := pair{dx / g, dy / g}
+			cnt[k]++
+			if ans < cnt[k]+1 {
+				ans = cnt[k] + 1
+			}
 		}
 	}
 	return ans
 }
 
 func gcd(a, b int) int {
-	for b != 0 {
-		a, b = b, a%b
+	if b == 0 {
+		return a
 	}
-	return a
+	return gcd(b, a%b)
 }
+```
 
-func max(a, b int) int {
-	if a > b {
-		return a
-	}
-	return b
+### **C#**
+
+```cs
+public class Solution {
+    public int MaxPoints(int[][] points) {
+        int n = points.Length;
+        int ans = 1;
+        for (int i = 0; i < n; ++i) {
+            int x1 = points[i][0], y1 = points[i][1];
+            for (int j = i + 1; j < n; ++j) {
+                int x2 = points[j][0], y2 = points[j][1];
+                int cnt = 2;
+                for (int k = j + 1; k < n; ++k) {
+                    int x3 = points[k][0], y3 = points[k][1];
+                    int a = (y2 - y1) * (x3 - x1);
+                    int b = (y3 - y1) * (x2 - x1);
+                    if (a == b) {
+                        ++cnt;
+                    }
+                }
+                if (ans < cnt) {
+                    ans = cnt;
+                }
+            }
+        }
+        return ans;
+    }
 }
 ```