LeetCode Max Points on a Line

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

 强行解：

inline bool valueSame(double a, double b) {
    return abs(a - b) < 0.01;
}

class Line {
public:
    double k;
    double d;
    bool infiniteK;
    Line(){};
    Line(double _k, double _d) : k(_k), d(_d), infiniteK(false) {}
    Line(double _k) : k(_k), d(0.0), infiniteK(true) {}
    
    bool operator==(const Line& line) const {
        if (infiniteK != line.infiniteK) {
            return false;
        } else if (line.infiniteK) {
            return valueSame(k, line.k);
        }
        return valueSame(k, line.k) && valueSame(d, line.d);
    }
};

struct LineHashFunc {
    size_t operator() (const Line& line) const {
        return  (std::hash<double>()(line.k))
        ^ (std::hash<double>()(line.d))
        ^ (std::hash<bool>()(line.infiniteK));
    }
};

struct PointHashFunc {
    size_t operator() (const Point& point) const {
        return (hash<int>()(point.x)) ^ (hash<int>()(point.y) << 1);
    }
};

struct PointEqualFunc {
    bool operator()(const Point& a, const Point& b) const {
        return valueSame(a.x, b.x) && valueSame(a.y, b.y);
    }
};


class Solution {
public:
    unordered_map<Line, unordered_set<int>, LineHashFunc> pts;
    int line_count;
    Line maxline;
    
public:
    int maxPoints(vector<Point>& points) {
        pts.clear();
        line_count = 0;
        unordered_map<Point, int, PointHashFunc, PointEqualFunc> pnums;
        int max_pnums = 0;
        for (Point& p : points) {
            max_pnums = max(max_pnums, ++pnums[p]);
        }
        int len = points.size();
           
        for (int i=0; i<len; i++) {
            Point& a = points[i];
            vector<Line> lines;
            for (int j = i + 1; j<len; j++) {
                Point& b = points[j];
                if (valueSame(a.x, b.x)) {
                    if (!valueSame(a.y, b.y)) {
                        lines.push_back(Line(a.x));
                        inc(lines.back(), i, j);
                    } else {
                        for (Line line : lines) {
                            inc(line, i, j);
                        }
                    }
                    continue;
                }
                double k = (a.y - b.y) * 1.0 / (a.x - b.x);
                double d = a.y - k * a.x;
                lines.push_back(Line(k, d));
                inc(lines.back(), i, j);
            }
        }
        return max(max_pnums, line_count);
    }
    
    void inc(Line a, int ia, int ib) {
        if (!pts.count(a)) {
            pts[a] = unordered_set<int>();
        }
        
        pts[a].insert(ia);
        pts[a].insert(ib);
        
        if (pts[a].size() > line_count) {
            line_count = pts[a].size();
            maxline = a;
        }
    }
};

能把程序写成这样真是太忧伤了。以上是从全局的角度考虑，等算出所有可能的直线后进行最大值提取。

从discuss中找了个高大上的：从局部考虑，过一点，再加个斜率，一条直线就确定了，逐步计算过这些线的点，取最大的即可。

/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 *     Point() : x(0), y(0) {}
 *     Point(int a, int b) : x(a), y(b) {}
 * };
 */
class Solution {
public:
    int maxPoints(vector<Point>& points) {
        int len = points.size();
        if (len <= 2) {
            return len;
        }
        int maxon = 0;;
        for (int i=0; i<len; i++) {
            Point& a = points[i];
            unordered_map<double, int> lines;
            int normal = 1;
            int vertical = 1;
            int duplicate= 0;
            for (int j=i+1; j<len; j++) {
                Point& b = points[j];
                if (a.x == b.x) {
                    if (a.y == b.y) {
                        duplicate++;
                    } else {
                        vertical++;
                    }
                } else {
                    double k = (a.y - b.y) * 1.0 / (a.x - b.x);
                    lines[k] += !lines[k] + 1;
                    normal = max(normal, lines[k]);
                }
            }
            maxon = max(maxon, max(normal + duplicate, vertical + duplicate));
        }
        return maxon;
    }
};