LeetCode - Max Points on a Line

Max Points on a Line

2014.2.26 18:13

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

Solution1:

　　A simple solution to this problem is O(n^3). Scan every pair of points and see if others are on the line with them. Simple but not efficient.

　　The second solution will be more efficient, but requires hashing. For each point p, if there're k other points that can form lines with the same slope with this point, they're all on the same line. When recording the slopes, you need hashing to assist you.

　　The hashing could choose the slope rate y/x as the hash key, but you know it would involve float point calculation, which is liable to accuracy problem.

　　I chose to record the slop with a pair (x, y), where y/x means the slope rate. (0, 1) means vertical line to the x-axis, while 1/0 is not a valid slope rate. This way of representation is more universal, but requires a little bit more coding.

　　I had intended to use <unordered_map> as the hashing tool, but the code wouldn't compile and run, as I've never used any user-defined type as hash key before. So I switched for <map> to solve the problem. The code is relatively simple, only a few things to remind you here:

　　　　1. There're duplicate points.

　　　　2. There're vertical lines.

　　　　3. All coordinates are integers and you don't have to worry about integer overflow.

　　Time complexity is O(n^2 * log(n)), space complexity is O(n).

Accepted code:

// 8CE, 1AC, solution with <map>, I'll try <unordered_map> later.
#include <map>
#include <vector>
using namespace std;

/*
struct Point {
    int x;
    int y;
    Point() : x(0), y(0) {}
    Point(int a, int b) : x(a), y(b) {}
};
*/

struct st {
    int x;
    int y;
    st(int _x = 0, int _y = 0): x(_x), y(_y) {};

    bool operator == (const st &other) const {
        return x == other.x && y == other.y;
    }

    bool operator != (const st &other) const {
        return x != other.x || y != other.y;
    }

    bool operator < (const st &other) const {
        if (x == other.x) {
            return y < other.y;
        } else {
            return x < other.x;
        }
    }
};

class Solution {
public:
    int maxPoints(vector<Point> &points) {
        int n = (int)points.size();
        
        if (n <= 2) {
            return n;
        }
        
        map<st, int> um;
        st tmp;
        // special tangent value for duplicate points
        st dup(0, 0);
        
        int i, j;
        map<st, int>::const_iterator umit;
        int dup_count;
        int max_count;
        int result = 0;
        for (i = 0; i < n; ++i) {
            for (j = i + 1; j < n; ++j) {
                tmp.x = points[j].x - points[i].x;
                tmp.y = points[j].y - points[i].y;
                // make sure one tangent value has one representation only.
                normalize(tmp);
                if (um.find(tmp) != um.end()) {
                    ++um[tmp];
                } else {
                    um[tmp] = 1;
                }
            }
            max_count = dup_count = 0;
            for (umit = um.begin(); umit != um.end(); ++umit) {
                if (umit->first != dup) {
                    max_count = (umit->second > max_count ? umit->second : max_count);
                } else {
                    dup_count = umit->second;
                }
            }
            max_count = max_count + dup_count + 1;
            result = (max_count > result ? max_count : result);
            um.clear();
        }
        
        return result;
    }
private:
    void normalize(st &tmp) {
        if (tmp.x == 0 && tmp.y == 0) {
            // (0, 0)
            return;
        }
        if (tmp.x == 0) {
            // (0, 1)
            tmp.y = 1;
            return;
        }
        if (tmp.y == 0) {
            // (1, 0)
            tmp.x = 1;
            return;
        }
        if (tmp.x < 0) {
            // (-2, 3) and (2, -3) => (2, -3)
            tmp.x = -tmp.x;
            tmp.y = -tmp.y;
        }
        
        int gcd_value;
        
        gcd_value = (tmp.y > 0 ? gcd(tmp.x, tmp.y) : gcd(tmp.x, -tmp.y));
        // (4, -6) and (-30, 45) => (2, -3)
        // using a double precision risks in accuracy
        // so I did it with a pair
        tmp.x /= gcd_value;
        tmp.y /= gcd_value;
    }
    
    int gcd(int x, int y) {
        // used for reduction of fraction
        return y ? gcd(y, x % y) : x;
    }
};

Solution2:

　　This is the version using <unordered_map>.

　　Time complexity is O(n^2), space complexity is O(n).

　　If you're not familiar with the usage of functor, perhaps you might see the code below for reference.

Accepted code:

// 1CE, 1AC, unordered_map with user-defined key.
#include <unordered_map>
#include <vector>
using namespace std;
/*
struct Point {
    int x;
    int y;
    Point() : x(0), y(0) {}
    Point(int a, int b) : x(a), y(b) {}
};
*/
struct st {
    int x;
    int y;
    st(int _x = 0, int _y = 0): x(_x), y(_y) {};

    bool operator == (const st &other) const {
        return x == other.x && y == other.y;
    };

    bool operator != (const st &other) const {
        return x != other.x || y != other.y;
    };
};

struct hash_functor {
    size_t operator () (const st &a) const {
        return (a.x * 1009 + a.y);
    }
};

struct compare_functor {
    bool operator () (const st &a, const st &b) const {
        return (a.x == b.x && a.y == b.y);
    }
};

typedef unordered_map<st, int, hash_functor, compare_functor> st_map;

class Solution {
public:
    int maxPoints(vector<Point> &points) {
        int n = (int)points.size();
        
        if (n <= 2) {
            return n;
        }
        
        st_map um;
        st tmp;
        // special tangent value for duplicate points
        st dup(0, 0);
        
        int i, j;
        st_map::const_iterator umit;
        int dup_count;
        int max_count;
        int result = 0;
        for (i = 0; i < n; ++i) {
            for (j = i + 1; j < n; ++j) {
                tmp.x = points[j].x - points[i].x;
                tmp.y = points[j].y - points[i].y;
                // make sure one tangent value has one representation only.
                normalize(tmp);
                if (um.find(tmp) != um.end()) {
                    ++um[tmp];
                } else {
                    um[tmp] = 1;
                }
            }
            max_count = dup_count = 0;
            for (umit = um.begin(); umit != um.end(); ++umit) {
                if (umit->first != dup) {
                    max_count = (umit->second > max_count ? umit->second : max_count);
                } else {
                    dup_count = umit->second;
                }
            }
            max_count = max_count + dup_count + 1;
            result = (max_count > result ? max_count : result);
            um.clear();
        }
        
        return result;
    }
private:
    void normalize(st &tmp) {
        if (tmp.x == 0 && tmp.y == 0) {
            // (0, 0)
            return;
        }
        if (tmp.x == 0) {
            // (0, 1)
            tmp.y = 1;
            return;
        }
        if (tmp.y == 0) {
            // (1, 0)
            tmp.x = 1;
            return;
        }
        if (tmp.x < 0) {
            // (-2, 3) and (2, -3) => (2, -3)
            tmp.x = -tmp.x;
            tmp.y = -tmp.y;
        }
        
        int gcd_value;
        
        gcd_value = (tmp.y > 0 ? gcd(tmp.x, tmp.y) : gcd(tmp.x, -tmp.y));
        // (4, -6) and (-30, 45) => (2, -3)
        // using a double precision risks in accuracy
        // so I did it with a pair
        tmp.x /= gcd_value;
        tmp.y /= gcd_value;
    }
    
    int gcd(int x, int y) {
        // used for reduction of fraction
        return y ? gcd(y, x % y) : x;
    }
};