LeetCode Max Points on a Line

平面上的点，求共线的最大点数。

Naive解法，对每两个点确定的直线，计算与这条直线共线的点数。未做优化，147ms。

/**
 * Definition for a point.
 * struct Point {
 *     int x;
 *     int y;
 * }
 */
 
// （在float的==比较中，隐含Nan != any not Nan，0.0 == -0.0，尤其注意！！）
#define Slope(i, j) (((double)(j.y) - i.y) / (j.x - i.x))
 
int maxPoints(struct Point* points, int pointsSize) {
    int i, j, k, res = 2;
    if (pointsSize <= 2)    // 少于3个点，返回点数。
        return pointsSize;
    for (i = 0 ; i < pointsSize ; i++)
        for (j = 0 ; j < pointsSize ; j++) {
            if (i == j) continue;
            int p = 2; // 至少有两个点共线了
            for (k = 0 ; k < pointsSize ; k++) {
                if (k == i || k == j)   continue;  // 三点不同
                if (points[i].x == points[k].x && points[i].y == points[k].y)
                    p++; // 重合点
                else if (points[j].x == points[k].x && points[j].y == points[k].y)
                    p++; // 重合点
                else if (points[i].x == points[j].x && points[j].x == points[k].x)
                    p++; // 斜率均不存在时
                else if (Slope(points[i], points[j]) == Slope(points[j], points[k]))
                    p++; // 否则，其中斜率之一存在，判断斜率是否相等。（在float的==比较中，隐含Nan != any not Nan，0.0 == -0.0，尤其注意！！）
            }
            if (p > res)
                res = p;
        }
    return res;
}

可以用hash对其进行优化（4ms过）。思想是，对每一个点，计算其它节点与他的斜率，放入一个hashtable并计数，最终取hashtalbe中累计最多的一个。

注意计算斜率的宏Slope，当两点斜率为无穷大时，我们设斜率为float的最大值，保证了逻辑上的Inf != any other && Inf == Inf，注意这里的等号和不等号是针对与二进制的物理表示的，因为我们在hashtable中，key的相等是依据直接比较二进制物理表示。

当两点斜率是0时，我们手动赋值0.0，否则可能出现-0.0物理内存不等于0.0的情况，从而在hashtable中认为是不同的key。

也就是说，naive中key的比较用的是C语言中的==和!=，所以不用关心物理表示；但在我们写的hashtable中，key的相同依据物理内存，因此需要我们对Slope做额外的确保。

#define Slope(i, j) (j.x == i.x ? 4294967295.0f : \
                    j.y == i.y ? 0.0f : ((float)(j.y-i.y)) / (j.x-i.x))

struct Mystruct {
    float slope;
    int num;
    struct B_HashHandle hh;
};
 
int maxPoints(struct Point* points, int pointsSize) {
    int i, j, k, res = 0;
    if (pointsSize <= 2)  // 少于3个节点返回点数
        return pointsSize;
    struct Mystruct* mystruct = malloc(sizeof(struct Mystruct) * pointsSize); // 最多hashtable中可能插入点数相同个元素
    struct B_HashTable* ht = hashInit(struct Mystruct);
    for (i = 0 ; i < pointsSize ; i++) {
        hashClear(ht);
        int t = 0, cnt = 0; // cnt累计了重合点个数
        for (j = i+1 ; j < pointsSize ; j++) { // j从i+1开始，必须保证0.0 == -0.0的判断（在这里WA了，用GDB调了半天）
            if (points[i].x == points[j].x && points[i].y == points[j].y)
                cnt++;
            else {
                mystruct[t].slope = Slope(points[i], points[j]);
                struct Mystruct* ret = hashSafeInsertField(ht, mystruct[t], slope);
                if (ret)
                    ret->num++;
                else {
                    mystruct[t].num = 1;
                    t++;
                }
            }
        }
        if (cnt > res) // 若没有此举，考虑这样的例子：三点重合，则以下循环不会发生，res不会更新为cnt
            res = cnt;
        struct Mystruct* iter = hashIter(ht);
        for ( ; iter ; iter = hashIterNext(ht, iter))
            if (cnt + iter->num > res)
                res = cnt + iter->num;
    }
    hashDestroy(ht);
    free(mystruct);
    return res + 1; // 最后要算上自己（我们的工作是，对每一个点，计算其它节点与他的斜率，放入一个hashtable并计数，最终还需累计他自己共线）
}