LeetCode 149. Max Points on a Line

Problem Statement

(Source) Given n points on a 2D plane, find the maximum number of points that lie on the same straight line.

Solution

Tags: Hash Table, Math.

Note: In Java version of pre-defined code, coordinates of points are pre-defined as integers. So I assume the same applies here in python version.

class Solution(object):
    def maxPoints(self, points):
        """
        :type points: List[Point]
        :rtype: int
        """
        res = 0
        n = len(points)
        for i in xrange(n):
            memo = {}
            duplicate = 0
            for j in xrange(n):
                if (points[j].x, points[j].y) == (points[i].x, points[i].y):
                    duplicate += 1
                elif points[j].x == points[i].x:
                    memo['v'] = memo.get('v', 0) + 1
                elif points[j].y == points[i].y:
                    memo['h'] = memo.get('h', 0) + 1
                else:
                    k = self.slope(points[i], points[j])
                    memo[k] = memo.get(k, 0) + 1
            res = max(res, max(memo.values()) + duplicate if memo else duplicate)
        return res

    def gcd(self, x, y):
        while x % y: x, y = y, x%y
        return y

    def slope(self, p1, p2):
        res = ''
        flag = 1
        x = p1.x - p2.x
        y = p1.y - p2.y
        if x < 0:
            flag *= -1
            x = -x
        if y < 0:
            flag *= -1
            y = -y
        m = self.gcd(x, y)
        if flag == -1:
            res='-'
        res += (str(x/m) + '/' + str(y/m))
        return res

Complexity analysis:

• Time complexity: $O(n^2 \cdot gcd)$. For time complexity analysis of gcd, see below reference.

References

(1) Time complexity of Euclid’s Algorithm.