149. Max Points on a Line

/**
 * 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:
    bool product(Point a,Point b,Point c){
        return (long(b.x-a.x)*(c.y-a.y)-long(b.y-a.y)*(c.x-a.x))==0;
    }
    bool equal(Point a,Point b){
        return a.x==b.x&&a.y==b.y;
    }
    static bool cmp(Point a,Point b){
        if(a.x==b.x)return a.y<b.y;
        return a.x<b.x;
    }
    int maxPoints(vector<Point>& points) {
        if(points.size()<=2)return points.size();
        sort(points.begin(),points.end(),cmp);
        int ans=0,temp=0;
        for(int i=0;i<points.size()-2;i++){
            //if(i&&equal(points[i],points[i-1]))continue;
            for(int j=i+1;j<points.size()-1;j++){
                temp=2;
                while(j<points.size()-1&&equal(points[j],points[i])){temp++;j++;}
                for(int k=j+1;k<points.size();k++){
                    if(product(points[i],points[j],points[k]))temp++;
                }
                ans=max(ans,temp);
            }
        }
        return ans;
    }
};

/**
 * 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:
    bool product(Point a,Point b,Point c){
        return (long(b.x-a.x)*(c.y-a.y)-long(b.y-a.y)*(c.x-a.x))==0;
    }
    bool equal(Point a,Point b){
        return a.x==b.x&&a.y==b.y;
    }
    int maxPoints(vector<Point>& points) {
        if(points.size()<=2)return points.size();
        int ans=0,temp=0,extra=0;
        for(int i=0;i<points.size();i++){
            extra=0;
            for(int j=i+1;j<points.size();j++){
                if(equal(points[j],points[i])){extra++;ans=max(ans,extra+1);continue;}
                temp=1;
                for(int k=j+1;k<points.size();k++){
                    if(product(points[i],points[j],points[k]))temp++;
                }
                ans=max(ans,extra+temp+1);
            }
        }
        return ans;
    }
};

class Solution {
public:
    int maxPoints(vector<Point> &points) {
        
        if(points.size()<2) return points.size();
        
        int result=0;
        
        for(int i=0; i<points.size(); i++) {
            
            map<pair<int, int>, int> lines;
            int localmax=0, overlap=0, vertical=0;
            
            for(int j=i+1; j<points.size(); j++) {
                
                if(points[j].x==points[i].x && points[j].y==points[i].y) {
                    
                    overlap++;
                    continue;
                }
                else if(points[j].x==points[i].x) vertical++;
                else {
                    
                    int a=points[j].x-points[i].x, b=points[j].y-points[i].y;
                    int gcd=GCD(a, b);
                    
                    a/=gcd;
                    b/=gcd;
                    
                    lines[make_pair(a, b)]++;
                    localmax=max(lines[make_pair(a, b)], localmax);
                }

                localmax=max(vertical, localmax);
            }
            
            result=max(result, localmax+overlap+1);
        }
        
        return result;
    }

private:
    int GCD(int a, int b) {
        
        if(b==0) return a;
        else return GCD(b, a%b);
    }
};