Leetcode_max-points-on-a-line(c++ and python version)

地址：http://oj.leetcode.com/problems/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.、

思路：brute ways，O(N^2)时间复杂度。

如果x轴坐标一致：

1. Y轴坐标也一样的话就是同一个点，用same标记

2. Y轴坐标不一样，在一条垂直线上，用vertical标记

如果x轴坐标不一样，则可以计算斜率：

3. 以任一个点(遍历)为起点，计算其与每一个点的斜率。斜率用hash表(字典)来存储。

其中3和2值中的较大值加上1值即为结果

c++ 参考代码：

/** * 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) {        if(points.empty())            return 0;        unordered_map<double, int>dm;        int ans = 0, vertical = 0, same = 0, maxdm = 0;        double dslope = 0.0;        for(int i = 0; i<points.size(); ++i)        {            dm.clear();            dslope = vertical = same = maxdm = 0;            for(int j = 0; j<points.size(); ++j)            {                if(points[i].x==points[j].x)                {                    if(points[i].y==points[j].y)                        ++same;                    else                        ++vertical;                }                else                {                    dslope = (double)(points[j].y-points[i].y) / (points[j].x-points[i].x);                    ++dm[dslope];                    maxdm = max(maxdm, dm[dslope]);                }            }            ans = max(ans, max(vertical, maxdm)+same);        }        return ans;    }};

python参考代码：

# Definition for a point# class Point:#     def __init__(self, a=0, b=0):#         self.x = a#         self.y = bclass Solution:    # @param points, a list of Points    # @return an integer    def maxPoints(self, points):        if not points:return 0        ans = 0        slope = 0.0        for i in points:            dict = {}            maxdict = vertical = same = 0            for j in points:                if i.x==j.x:                    if i.y==j.y:                        same += 1                    else:                        vertical += 1                else:                    slope = float(j.y-i.y) / (j.x-i.x)                    if dict.has_key(slope):                        dict[slope] += 1                    else:                        dict[slope] = 1                    maxdict = max(maxdict, dict[slope])            ans = max(ans, max(maxdict, vertical)+same)        return ans            

//SECOND TRIAL, almost the same
class Solution {
public:
    int maxPoints(vector<Point> &points) {
        if(points.empty())
            return 0;
        else if(points.size()<=2)
            return points.size();
        int same = 0, vertical = 0, slope_cnt = 0, ans = 0;
        float slope;
        unordered_map<float, int>mp;
        for(int i = 0; i<points.size(); ++i)
        {
            same = vertical = slope_cnt = 0;
            mp.clear();
            for(int j = 0; j<points.size(); ++j)
            {
                if(j != i)
                {
                    if(points[j].x == points[i].x)
                    {
                        if(points[j].y==points[i].y)
                            ++same;
                        else
                            ++vertical;
                    }
                    else
                    {
                        slope = float(points[j].y - points[i].y) / (points[j].x - points[i].x);
                        ++mp[slope];
                        if(mp[slope] > slope_cnt)
                            slope_cnt = mp[slope];
                    }
                }
            }
            ans = max(ans, 1+same+max(slope_cnt, vertical));
        }
        return ans;
    }
};