leetcode-149. 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.

分析

• 暴力枚举法。两点决定一条直线， n 个点两两组合，可以得到 1/2n(n + 1) 条直线，对每一条直线，判断 n 个点是否在该直线上，从而可以得到这条直线上的点的个数，选择最大的那条直线返回。复杂度 O(n3)。

• 上面的暴力枚举法以“边”为中心，再看另一种暴力枚举法，以每个“点”为中心，然后遍历剩余点，找到所有的斜率，如果斜率相同，那么一定共线对每个点，用一个哈希表， key 为斜率， value为该直线上的点数，计算出哈希表后，取最大值，并更新全局最大值，最后就是结果。时间复杂度O(n2)，空间复杂度 O(n)

• 注意这道题的编译精度

分析：
任意一条直线都可以表述为
y = ax + b
假设，有两个点(x1,y1), (x2,y2)，如果他们都在这条直线上则有
y1 = kx1 +b
y2 = kx2 +b
由此可以得到关系，k = (y2-y1)/(x2-x1)。即如果点c和点a的斜率为k, 而点b和点a的斜率也为k，可以知道点c和点b也在一条线上。
取定一个点points[i], 遍历其他所有节点, 然后统计斜率相同的点数，并求取最大值即可

AC代码

#include <iostream>
using namespace std;
#include <vector>
#include <unordered_map>

#define max(a,b)    (((a) > (b)) ? (a) : (b))

//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.size()<3)
			return points.size();
		int result = 0;
		unordered_map<double, int> slope_count;

		for (int i = 0; i<points.size() - 1; i++)
		{
			slope_count.clear();
			int samePointNum = 0; //与i重合的点
			int point_max = 1; //和i共线的最大点数
			for (int j = i + 1; j<points.size(); j++)
			{
				double slope; //斜率
				if (points[i].x == points[j].x)
				{
					slope = std::numeric_limits<double>::infinity(); //防止重复元素没有斜率
					if (points[i].y == points[j].y)
					{
						samePointNum++;
						continue;
					}
				}
				else
				{
					slope = 1.0*(points[i].y - points[j].y) / (points[i].x - points[j].x);
				}

				int count = 0;
				if (slope_count.find(slope) != slope_count.end())
					count = ++slope_count[slope];
				else
				{
					count = 2;
					slope_count[slope] = 2;
				}
				if (point_max<count)
					point_max = count;
			}
			result = max(result, point_max + samePointNum);
		}
		return result;
	}
};


class Solution1 {
public:
	int maxPoints(vector<Point>& points)
	{
		if (points.size() <= 2) return points.size();
		int res = 0;
		for (int i = 0; i < points.size() - 1; i++) {
			int numVertical = 1, local = 1, duplicate = 0;
			unordered_map<double, int> map;
			for (int j = i + 1; j < points.size(); j++)
			if (points[i].x == points[j].x) // special cases
			if (points[i].y == points[j].y) // duplicate 
				duplicate++;
			else // vertical
				numVertical++;
			else {
				double slope = (points[i].y - points[j].y)*1.0 / (points[i].x - points[j].x);  //斜率有浮点精度的问题
				map[slope] == 0 ? map[slope] = 2 : map[slope]++;
				local = max(local, map[slope]);
			}
			local = max(local + duplicate, numVertical + duplicate);
			res = max(res, local);
		}
		return res;
	}
};

class Solution2  //可能跟编译器有关吧，vs2013下输出3，但是在leetcode下通过了
{
public:
	int maxPoints(vector<Point>& points) { // O(n^2)
		int result = 0;
		for (int i = 0; i < points.size(); i++) {
			auto &p1 = points[i];
			unordered_map<long double, int> hashT;
			int verticals = 1, duplicates = 0, local = 1;
			for (int j = i + 1; j < points.size(); j++) {
				auto &p2 = points[j];
				if (p1.y == p2.y && p1.x == p2.x) duplicates++;
				else if (p1.x == p2.x) verticals++;
				else {
					auto slope = static_cast<long double>(p1.y - p2.y) / (p1.x - p2.x);
					hashT[slope] = hashT[slope] ? 1 + hashT[slope] : 2;
					local = max(local, hashT[slope]);
				}
				local = max(local, verticals);
			}
			result = max(result, local + duplicates);
		}
		return result;
	}

};


//
//Your input
//
//[[0, 0], [94911151, 94911150], [94911152, 94911151]]
//Your answer
//
//3
//Expected answer
//
//2
int main()
{

	Solution2 S;
	vector<Point> points;
	Point p1(0, 0), p2(94911151, 94911150), p3(94911152, 94911151);//[[0,0],[94911151, 94911150],[94911152, 94911151]] //[[0,0],[-1,-1],[2,2]]



	points.push_back(p1);
	points.push_back(p2);
	points.push_back(p3);

	int ret=S.maxPoints(points);

	cout << ret << endl;

	return 0;
}

• 测试用例:[(0,0),(-1,-1),(2,2)]没有通过！

reference

• Leetcode: Max Points on a Line