Codeforces: Empty Triangle

　　这是codeforces gym中的2011-2012 Stanford Local Contest, 8 October, 2011的一道几何题。题意很简单，就是给出500条直线，问你有多少个不被其他直线穿过的三角形。这道题一个很简单的思路就是先要找出每条直线上的交点，因为如果图形是空三角形，那么组成三角形的的每两个顶点都是某条直线上相邻的两个交点。于是我们利用直线的标号，用某条直线上所有点相邻的两条直线与该直线组成三角形，很容易可以找到最多不超过250000个三角形。其中必然会有重复的三角形。如果三角形重复次数是3（最多也只能是3），那么这个就是一个空三角形。用multiset可以很方便的统计重复次数，或者用hash统计也可以。不过现在想到，好像直接make完pair以后排个序直接统计就好了。。囧！

　　题目如下：

Empty Triangles

Problem Description

Do you know how easy it is to make a very simple problem into a brutally hard one? Here is an example. How many triangles can you make with N straight lines in the plane? As long as they have different slopes and no three of them meet at a single point, there will be triangles, which is the maximum possible you can get.
Okay, that wasn't too bad. But let's see what happens if we only count triangles that are empty (that is, none of the lines pass through the interior of the triangle). Then, the number of triangles suddenly becomes very small. For example, with 4 straight lines, we can only make 2 empty triangles, whereas the total number of triangles can be as big as 4. Refer to the diagram.
In fact, a general formula for the maximum number of empty triangles that can be drawn with N lines is not known. The hard part, however, is to find the right configuration of the lines. Your job is much easier; given N straight lines on the plane, count the number of empty triangles.

Input

The input consists of multiple test cases. Each test case begins with a line containing an integer N, 1 ≤ N ≤ 500, which indicates the number of lines on the plane. The next N lines each contain four integers x1, y1, x2, and y2 (between -1000 and 1000), representing a straight line that goes through (x1, y1) and (x2, y2). It is guaranteed that no three lines meet at the same point, and all the lines are distinct.  The input terminates with a line with N = 0.

Output

For each test case, print out a single line that contains the number of empty triangles formed by the given lines.

Sample Input

4 
0 0 1 2 
0 0 -1 2 
1 0 1 1 
-1 0 -1 -1 
5 
0 0 1 0 
0 1 1 1 
0 2 1 2 
0 3 1 3 
0 4 1 4 
0

Sample Output

2
0

这是3400ms+通过的代码：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <set>
#include <cassert>
#include <vector>

#define feq(a, b) (fabs((a) - (b)) < eps)

using namespace std;

typedef pair<int, int> pii;
typedef pair<pii, int> piii;
typedef vector<double> vdb;
typedef vector<int> vi;

const int maxn = 505;
const double eps = 1e-6;
const int mod = 1000007;

int hash[mod][3], cnt[mod];
//multiset<piii> cnt;

bool judge(int *a, int *b){
    for (int i = 0; i < 3; i++){
        if (a[i] != b[i]) return true;
    }
    return false;
}

bool insert(int *a){
    int p = ((a[0] << 16) + (a[1] << 8) + a[2]) % mod;

    if (p < 0){
        p += mod;
    }
    while (judge(hash[p], a) && cnt[p]) p = (p + 1) % mod;
    for (int i = 0; i < 3; i++){
        hash[p][i] = a[i];
    }
    cnt[p]++;
    if (cnt[p] == 3) return true;
    return false;
}

struct point{
    int id;
    double x, y;
    bool operator < (const point &a) const{
        if (feq(x, a.x)) return y < a.y;
        return x < a.x;
    }
};

struct Line{
    point a, b;
    vector<point> cross;
    void fix(){
        sort(&cross[0], &cross[0] + cross.size());
    }
}line[maxn];

bool parallel(Line u, Line v){
    return feq((u.a.x - u.b.x) * (v.a.y - v.b.y), (v.a.x - v.b.x) * (u.a.y - u.b.y));
}

point ll_inst(Line l1, Line l2){
    point ans = l1.a;
    double t = ((l1.a.x - l2.a.x) * (l2.a.y - l2.b.y) - (l1.a.y - l2.a.y) * (l2.a.x - l2.b.x))
    / ((l1.a.x - l1.b.x) * (l2.a.y - l2.b.y) - (l1.a.y - l1.b.y) * (l2.a.x - l2.b.x));

    ans.x += (l1.b.x - l1.a.x) * t;
    ans.y += (l1.b.y - l1.a.y) * t;

    return ans;
}

int id[3];

int main(){
    int n;
    point tmp;

    while (~scanf("%d", &n) && n){
        //cnt.clear();
        memset(cnt, 0, sizeof(cnt));
        for (int i = 0; i < n; i++){
            line[i].cross.clear();
            scanf("%lf%lf%lf%lf", &line[i].a.x, &line[i].a.y, &line[i].b.x, &line[i].b.y);
            for (int j = 0; j < i; j++){
                if (parallel(line[i], line[j])) continue;
                tmp = ll_inst(line[i], line[j]);
                tmp.id = j;
                line[i].cross.push_back(tmp);
                tmp.id = i;
                line[j].cross.push_back(tmp);
            }
        }
        for (int i = 0; i < n; i++){
            line[i].fix();
        }

        int out = 0;

        for (int i = 0; i < n; i++){
            int endj = line[i].cross.size();


            for (int j = 1; j <endj; j++){
                id[0] = i;
                id[1] = line[i].cross[j - 1].id;
                id[2] = line[i].cross[j].id;
                sort(id, id + 3);
                //cnt.insert(make_pair(make_pair(id[0], id[1]), id[2]));
                if (insert(id)) out++;
            }
        }
        /*
        multiset<piii>::iterator ii;
        piii pre = make_pair(make_pair(-1, -1), -1);

        for (ii = cnt.begin(); ii != cnt.end(); ii++){
            piii tt = (*ii);

            if (tt == pre){
                pre = tt;
                continue;
            }
            pre = tt;
            if (cnt.count(tt) == 3){
                //printf("%d %d %d\n", tt.first.first, tt.first.second, tt.second);
                out++;
            }
        }
        */
        /*
        for (int i = 0; i < mod; i++){
            if (cnt[i] == 3) out++;
        }
        */
        printf("%d\n", out);
    }

    return 0;
}

——written by Lyon