update 149

Author: luliyucoordinate

src/0149-Max-Points-on-a-Line/0149.cpp

@@ -1,66 +1,25 @@
-#include <iostream>
-#include <vector>
-#include <unordered_map>
-#include <climits>
-#include <map>
-using namespace std;
+class Solution {
+ public:
+  int maxPoints(vector<vector<int>>& points) {
+    int res = 1, n = points.size();
+    unordered_map<int, int> lines;
+    for (int i = 0; i < n; i++) {
+      lines.clear();
+      for (int j = i + 1; j < n; j++) {
+        auto& p1 = points[i];
+        auto& p2 = points[j];
 
-
- //Definition for a point.
-struct Point {
-    int x;
-    int y;
-    Point() : x(0), y(0) {}
-    Point(int a, int b) : x(a), y(b) {}
-};
-
-static int x = []() {std::ios::sync_with_stdio(false); cin.tie(0); return 0; }();
-class Solution 
-{
-public:
-    int maxPoints(vector<Point> &points) 
-    {       
-        if(points.size() < 2) return points.size();     
-        int result = 0;   
-        map<pair<int, int>, int> lines; 
-        for(unsigned int i = 0; i < points.size(); i++) {    
-            lines.clear();
-            int duplicate = 1, vertical = 1;           
-            for(unsigned int j = i + 1; j < points.size(); j++) 
-            {                
-                if(points[j].x == points[i].x && points[j].y == points[i].y) 
-                {                    
-                    duplicate++;
-                    continue;
-                }
-                else if(points[j].x == points[i].x) vertical++;
-                else 
-                {    
-                    int a = points[j].x - points[i].x;
-                    int b = points[j].y - points[i].y;
-                    int gcd = GCD(a, b);
-                    a /= gcd; b /= gcd;
-                    lines[make_pair(a, b)]++;
-                }
-            }  
-            if (result < duplicate) result = duplicate;
-            if (result < vertical) result = vertical;
-            for (auto& line : lines)
-            {
-                int tmp = duplicate + line.second;
-                if (result < tmp) result = tmp;
-            }      
-        }        
-        return result;
-    }
-private:
-    int GCD(int a, int b) 
-    {      
-        if(b == 0) return a;
-        else return GCD(b, a % b);
+        auto a = p1[0] - p2[0];
+        auto b = p1[1] - p2[1];
+        auto c = GCD(a, b);
+        a /= c, b /= c;
+        lines[a * 20000 + b]++;
+      }
+      for (auto& [x, y] : lines) {
+        res = max(res, y + 1);
+      }
     }
-};
-int main()
-{
-    return 0;
-}
+    return res;
+  }
+  int GCD(int a, int b) { return b == 0 ? a : GCD(b, a % b); }
+};

src/0149-Max-Points-on-a-Line/0149.py

@@ -1,40 +1,20 @@
-# Definition for a point.
-class Point:
-    def __init__(self, a=0, b=0):
-        self.x = a
-        self.y = b
-
-from collections import defaultdict
-from decimal import Decimal
 class Solution:
-    def maxPoints(self, points):
-        """
-        :type points: List[Point]
-        :rtype: int
-        """
-        slopes, result = defaultdict(int), 0
-        for i, point1 in enumerate(points): 
-            slopes.clear()
-            duplicate = 1
-            for _, point2 in enumerate(points[i+1:]):
-                if point1.x == point2.x and point1.y == point2.y:
-                    duplicate += 1
-                    continue
-
-                slope = float('inf') if point1.x == point2.x else \
-                            Decimal((point1.y - point2.y))/Decimal((point1.x - point2.x))
-
-                slopes[slope] += 1
-
-            if result < duplicate:
-                result = duplicate
-
-            for _, val in slopes.items():
-                if val + duplicate > result:
-                    result = val + duplicate
-
-        return result
 
-if __name__ == "__main__":
-    points = [Point(0, 0), Point(94911151, 94911150), Point(94911152, 94911151)]
-    print(Solution().maxPoints(points))
+    def maxPoints(self, points: List[List[int]]) -> int:
+        def GCD(a, b):
+            return a if b == 0 else GCD(b, a % b)
+
+        res, n = 1, len(points)
+        lines = defaultdict(int)
+        for i in range(n):
+            lines.clear()
+            for j in range(i + 1, n):
+                p1, p2 = points[i], points[j]
+                a, b = p1[0] - p2[0], p1[1] - p2[1]
+                c = GCD(a, b)
+                a //= c
+                b //= c
+                lines[a * 20000 + b] += 1
+            for _, v in lines.items():
+                res = max(res, v + 1)
+        return res