feat: add solutions to leetcode problem: No.0149. Max Points on a Line

Author: yanglbme

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

@@ -36,27 +36,90 @@
 +------------------->
 0 &nbsp;1 &nbsp;2 &nbsp;3 &nbsp;4 &nbsp;5 &nbsp;6</pre>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+在平面上确定一个点 `points[i]`，其他点与 `point[i]` 可以求得一个斜率，斜率相同的点意味着它们与 `points[i]` 在同一条直线上。
+
+所以可以用哈希表作为计数器，其中斜率作为 key，然后累计当前点相同的斜率出现的次数。斜率可能是小数，我们可以用分数形式表示，先求分子分母的最大公约数，然后约分，最后将“分子.分母” 作为 key 即可。
+
+需要注意，如果平面上有和当前点重叠的点，如果进行约分，会出现除 0 的情况，那么我们单独用一个变量 duplicate 统计重复点的个数，重复点一定是过当前点的直线的。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def maxPoints(self, points: List[List[int]]) -> int:
+        def gcd(a, b) -> int:
+            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 = collections.Counter()
+            t_max = duplicate = 0
+            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
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+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;
+            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 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));
+            }
+            res = Math.max(res, max + duplicate + 1);
+        }
+        return res;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}
 ```
 
 ### **...**

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

@@ -31,21 +31,78 @@
 	<li>All the <code>points</code> are <strong>unique</strong>.</li>
 </ul>
 
-
 ## Solutions
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def maxPoints(self, points: List[List[int]]) -> int:
+        def gcd(a, b) -> int:
+            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 = collections.Counter()
+            t_max = duplicate = 0
+            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
 ```
 
 ### **Java**
 
 ```java
-
+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;
+            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 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));
+            }
+            res = Math.max(res, max + duplicate + 1);
+        }
+        return res;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}
 ```
 
 ### **...**

solution/0100-0199/0149.Max Points on a Line/Solution.java

@@ -1,27 +1,34 @@
 class Solution {
-    public int maxPoints(Point[] points) {
-        if( points.length <= 2 ) return points.length;
-        int max = 2 ;
-        for( int i = 0 ; i < points.length ; i++ ){
-            int samePosition = 0;
-            int sameSlope = 1;
-            for( int j = i + 1 ; j < points.length ; j++ ){
-                long x1 = points[j].x - points[i].x;
-                long y1 = points[j].y - points[i].y;
-                if( x1 == 0 && y1 == 0 ){
-                    samePosition++;
-                } else {
-                    sameSlope++;
-                    for(int k = j + 1 ; k < points.length ; k++ ){
-                        long x2 = points[k].x - points[i].x;
-                        long y2 = points[k].y - points[i].y;
-                        if ( x1 * y2 == x2 * y1 ) sameSlope++;
-                    }
+    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;
+            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;
                 }
-                if(max < (samePosition + sameSlope)) max = samePosition + sameSlope;
-                sameSlope = 1;
+                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));
             }
+            res = Math.max(res, max + duplicate + 1);
         }
-        return max;
+        return res;
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
     }
 }

solution/0100-0199/0149.Max Points on a Line/Solution.py

@@ -0,0 +1,26 @@
+class Solution:
+    def maxPoints(self, points: List[List[int]]) -> int:
+        def gcd(a, b) -> int:
+            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 = collections.Counter()
+            t_max = duplicate = 0
+            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

solution/0400-0499/0447.Number of Boomerangs/README.md

@@ -63,7 +63,7 @@
 class Solution:
     def numberOfBoomerangs(self, points: List[List[int]]) -> int:
         n = len(points)
-        if len(points) < 3:
+        if n < 3:
             return 0
         number = 0
         for i in range(n):

solution/0400-0499/0447.Number of Boomerangs/README_EN.md

@@ -53,7 +53,7 @@
 class Solution:
     def numberOfBoomerangs(self, points: List[List[int]]) -> int:
         n = len(points)
-        if len(points) < 3:
+        if n < 3:
             return 0
         number = 0
         for i in range(n):

solution/0400-0499/0447.Number of Boomerangs/Solution.py

@@ -1,7 +1,7 @@
 class Solution:
     def numberOfBoomerangs(self, points: List[List[int]]) -> int:
         n = len(points)
-        if len(points) < 3:
+        if n < 3:
             return 0
         number = 0
         for i in range(n):

solution/summary.md

@@ -439,7 +439,7 @@
   - [0429.N-ary Tree Level Order Traversal](/solution/0400-0499/0429.N-ary%20Tree%20Level%20Order%20Traversal/README.md)
   - [0430.Flatten a Multilevel Doubly Linked List](/solution/0400-0499/0430.Flatten%20a%20Multilevel%20Doubly%20Linked%20List/README.md)
   - [0431.Encode N-ary Tree to Binary Tree](/solution/0400-0499/0431.Encode%20N-ary%20Tree%20to%20Binary%20Tree/README.md)
-  - [0432.All O`one Data Structure](/solution/0400-0499/0432.All%20O%60one%20Data%20Structure/README.md)
+  - [0432.All O one Data Structure](/solution/0400-0499/0432.All%20O%60one%20Data%20Structure/README.md)
   - [0433.Minimum Genetic Mutation](/solution/0400-0499/0433.Minimum%20Genetic%20Mutation/README.md)
   - [0434.Number of Segments in a String](/solution/0400-0499/0434.Number%20of%20Segments%20in%20a%20String/README.md)
   - [0435.Non-overlapping Intervals](/solution/0400-0499/0435.Non-overlapping%20Intervals/README.md)

solution/summary_en.md

@@ -439,7 +439,7 @@
   - [0429.N-ary Tree Level Order Traversal](/solution/0400-0499/0429.N-ary%20Tree%20Level%20Order%20Traversal/README_EN.md)
   - [0430.Flatten a Multilevel Doubly Linked List](/solution/0400-0499/0430.Flatten%20a%20Multilevel%20Doubly%20Linked%20List/README_EN.md)
   - [0431.Encode N-ary Tree to Binary Tree](/solution/0400-0499/0431.Encode%20N-ary%20Tree%20to%20Binary%20Tree/README_EN.md)
-  - [0432.All O`one Data Structure](/solution/0400-0499/0432.All%20O%60one%20Data%20Structure/README_EN.md)
+  - [0432.All O one Data Structure](/solution/0400-0499/0432.All%20O%60one%20Data%20Structure/README_EN.md)
   - [0433.Minimum Genetic Mutation](/solution/0400-0499/0433.Minimum%20Genetic%20Mutation/README_EN.md)
   - [0434.Number of Segments in a String](/solution/0400-0499/0434.Number%20of%20Segments%20in%20a%20String/README_EN.md)
   - [0435.Non-overlapping Intervals](/solution/0400-0499/0435.Non-overlapping%20Intervals/README_EN.md)