leetcode 149. Max Points on a Line

149. Max Points on a Line 

斜率需要考虑分母为0的情况。具体需要考虑两种特殊情况：一是在x相等的时候，斜率是无穷大；二是与当前节点完全相同的时候。

解法一：

用hash-map存储斜率和斜率出现的次数，其中duplicate是跟当前节点完全一样的节点，这个无法用斜率表示，就单独计算。并且在后面的时候先要计算res = max(res,duplicate)，这是因为可能后面所有的节点都与当前节点一模一样，hash中就没有存储的值，如果不先更新max，后面可能就不会做计算。在计算的时候，还需要加上duplicate，即it->second + duplicate，因为每个重复的节点都可以看作是跟任何斜率的线共线。

但是这个代码无法通过[[0,0],[94911151,94911150],[94911152,94911151]]，因为无论是float还是double都是有限计算的，这个可能是不共线的，但有限的位数上的值是一样的。

为什么unordered_map的初始化要在第一个for循环里面而不是外面？　　有重复

class Solution {
public:
    int maxPoints(vector<Point>& points) {
        int res = 0;
        for (int i = 0; i < points.size(); ++i) {
            unordered_map<float, int> m;
            int duplicate = 1;
            for (int j = i + 1; j < points.size(); ++j) {
                if (points[i].x == points[j].x && points[i].y == points[j].y) {
                    ++duplicate;
                } else if (points[i].x == points[j].x) {
                    ++m[INT_MAX];
                } else {
                    float slope = (float)(points[j].y - points[i].y) / (points[j].x - points[i].x);
                    ++m[slope];
                }
            }
            res = max(res, duplicate);
            for (auto it = m.begin(); it != m.end(); ++it) {
                res = max(res, it->second + duplicate);
            }
        }
        return res;
    }
};

解法二：

相对于解法一，解法二主要是解决了无限除法的问题

为什么斜率无限大也解决了？

class Solution {
public:
    int maxPoints(vector<vector<int>>& points) {
        int m = points.size();
        if(m <= 0)
            return 0;
        int n = points[0].size();
        if(n <= 0)
            return 0;
        int res = 0;
        for(int i = 0;i < m;i++){
            map<pair<int,int>,int> container;
            int duplicate = 1;
            for(int j = i + 1;j < m;j++){
                if(points[j][0] == points[i][0] && points[j][1] == points[i][1])
                    duplicate++;
                else{
                    int dx = points[j][0] - points[i][0];
                    int dy = points[j][1] - points[i][1];
                    int d = gcd(dx,dy);
                    container[{dx/d,dy/d}]++;
                }
            }
            res = max(res,duplicate);
            for(auto it = container.begin();it != container.end();it++)
                res = max(res,it->second + duplicate);
        }
        return res;
    }
    int gcd(int a,int b){
        return (b == 0) ? a : gcd(b, a % b);
    }
};