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.

Method I

解决思路和求最短不减子序列类似：

开一个数组lines，第k个位置存放的是有k个点的直线，由于这样的直线可能有多条，所以需要嵌套vector。 

每来一个新点，都要把它加到k=1的位置。这里是把一个点也当成一条直线。

如果当前点在有k个点的直线上，那么令k=k+1，把lines[k]中包含当前点的直线加到lines[k + 1]中。

否则，从k-1往回找到j，找到lines[j]为包含当前点的最长直线集，将其中包含包含当前点的直线都加到lines[j+1]中；

这里有几点要注意：

1. 每次遇到一个新点，如果它没有出现过，需要把它当成一条直线加到lines[1]中；如果已经出现过，就要把它加到lines[2]中；比如(1,1)这个点出现了两次，第一次把它加到lines[1]中，第二次，由于(1,1)-(1,1)实际包括了两个点了，所以要把它加到lines[2]中。

2. 在判断目标点是否在直线集上时需要分情况处理。当遇到直线集中的某条直线其实只是一个点，比如(1, 1) - (1,1)，那么目标点肯定是在这条“直线”上的，生成的新的直线要尽量让直线的两个端点不一样。假设目标点为(2, 1)，生成的新的直线就应该为(2, 2) - (1,1)；这才是一条具有三个点的直线((2,2), (1,1), (1, 1))。如果还是生成(1,1）- (1,1)这条直线，那么当再来一个新的点(3,4)时，我们就会认为(3,4)仍在(1,1)-(1,1）这条线上，因此会生成拥有4个点的直线，这样就出错了。

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

bool inLine(Point &p, pair<Point, Point> &line) {
    return (p.y - line.first.y) * (line.second.x - line.first.x) == 
        (line.second.y - line.first.y) * (p.x - line.first.x);
}

bool inLines(Point p, vector<pair<Point, Point> > &lines, vector<pair<Point, Point> > &ret) {
    bool isInLines = false;
    for (vector<pair<Point, Point> >::iterator it = lines.begin(); it != lines.end(); ++it) {
        if (inLine(p, *it)) {
            if (it->first.x != it->second.x || it->first.y != it->second.y) {
                ret.push_back(*it);
            } else if (p.x != it->first.x || p.y != it->first.y) {
                ret.push_back(pair<Point, Point>(p, it->first));
            } else {
                ret.push_back(*it);
            }
            isInLines = true;
        }
    }
    return isInLines;
}

void print(vector<vector<pair<Point, Point> > > &lines, int k) {
    cout << k << "-----------------------------------------------" << endl;
        for (int j = 0; j < lines[k - 1].size(); ++j) {
            cout << lines[k - 1][j].first.x << " " << lines[k - 1][j].first.y << "-"
            <<    lines[k - 1][j].second.x << " " << lines[k - 1][j].second.y << endl;
        }    
    cout << k << "-----------------------------------------------" << endl;
}
int maxPoints(vector<Point> &points) {            
    int n = points.size();
    if (n <= 2) return n;

    vector<vector<pair<Point, Point> > > lines;
    vector<pair<Point, Point> > l;
    l.push_back(pair<Point, Point>(points[0], points[0]));
    lines.push_back(l);
    int k = 1;

    for (int i = 1; i < n; ++i) {
        //cout << i << endl;
        vector<pair<Point, Point> > ps;
        if (inLines(points[i], lines[k - 1], ps)) {
            lines.push_back(ps); 
            k++;
            //print(lines, k);
        } else {
            for (int j = k - 2; j >= 0; --j) {
                vector<pair<Point, Point> > ps;
                if (inLines(points[i], lines[j], ps)) {
                    lines[j + 1].insert(lines[j + 1].end(), ps.begin(), ps.end());
                    //print(lines, j + 1);
                    break;
                }
            }
        }

        bool isExist = false;
        for (int j = 0; j < lines[0].size(); ++j) {
            if (lines[0][j].first.x == points[i].x
                    && lines[0][j].first.y == points[i].y) {
                isExist = true;
                break;
            }
        }
        
        if (!isExist) {
            lines[0].push_back(pair<Point, Point>(points[i], points[i]));
        } else {
            lines[1].push_back(pair<Point, Point>(points[i], points[i]));
        }
    }

    //print(lines, k);
    return k;
}

 8ms Accepted.

Method II

对每个点，计算它和其他点的斜率，如果斜率相同，证明这n个点在同一个直线上。这样就可以找到包含某个点的最大点集。然后再取最大就行了。

注意： 处理好重复点和垂直点。第i个点只需要和i+1之后的点比较。因为i之前的点都计算过了。时间复杂度O(n^2)。 80ms accepted，略慢。

/**
 * 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 n = points.size();
        if (n == 0) return 0;
        
        unordered_map<double, int> lines;
        int max = 1;
        for (int i = 0; i < n; ++i) {
            lines.clear();
            
            int dup = 1, m = 0;
            for (int j = i + 1; j < n; ++j) {
                if (points[i].x != points[j].x) {
                    double k = (points[i].y - points[j].y) * 1.0 / (points[i].x - points[j].x);
                    lines[k]++;
                    if (lines[k] > m) m = lines[k];
                } else if (points[i].y != points[j].y) {
                    lines[0]++;
                    if (lines[0] > m) m = lines[0];
                } else {
                    dup++;
                }
            }
            if (m + dup > max) max = m + dup;
        }
        
        return max;
    }
};