hdu 3629 Convex 平面点集能组成多少凸四边形 极角排序

Convex

Time Limit: 10000/4000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 369    Accepted Submission(s): 79

Problem Description

Your task is very simple. You will get the coordinates of n points in a plane. It is guaranteed that there are no three points on a straight line. You can choose any four points from these points to construct a quadrangle. Now, please tell me how many convex quadrangles you can construct.

 

 

Input

The first line of input contain an integer z (z ≤ 20), indicating the number of test cases.
For each test case, the first line contain an integer n (4 ≤ n ≤ 700), indicating the number of points. Each of the next n lines contains two integers x and y (-1000000 ≤ x, y ≤ 1000000), indicating the coordinate of corresponding point.

 

 

Output

For each test case, just output a single integer, the number of convex quadrangles you can construct.

 

 

Sample Input

  
  

   
   2
4
0 0
0 1
1 0
1 1
4
0 0
1 0
0 1
-1 -1
  
  

 

 

Sample Output

  
  

   
   1
0
  
  
  
  

   
   #include<iostream>
   
   
#include<cstdio>
   
   
#include<cmath>
   
   
#include<algorithm>
   
   
using namespace std;
   
   
const double pi=3.1415926535;
   
   
struct Point
   
   
{
   
   
    double x,y;//注意用double  如果用int会超时
   
   
};
   
   
Point a[1000];
   
   
double t[2100];
   
   
double dis(Point a, Point b){     return sqrt(0.0+(a.x-b.x)*(a.x-b.x) + (a.y-b.y)*(a.y-b.y));}
   
   
__int64 C(int n,int k)
   
   
{
   
   
    if(n<k) return 0;
   
   
    if(k==2) return (__int64)n*(n-1)/2;
   
   
    if(k==3) return (__int64)n*(n-1)*(n-2)/6;
   
   
    if(k==4) return (__int64)n*(n-1)*(n-2)*(n-3)/24;
   
   
}
   
   
int main()
   
   
{
   
   
    int ci;scanf("%d",&ci);
   
   
    while(ci--)
   
   
    {
   
   
        int n;scanf("%d",&n);
   
   
        for(int i=0;i<n;i++) scanf("%lf%lf",&a[i].x,&a[i].y);//注意用double  如果用int会超时
   
   
        __int64 cnt=C(n,4);//四边形总个数
   
   
        for(int i=0;i<n;i++)
   
   
        {
   
   
            int pl=0;//极角排序
   
   
            for(int j=0;j<n;j++)
   
   
            {
   
   
                if(i==j) continue;
   
   
                t[pl++]=acos((a[j].x-a[i].x)/dis(a[i],a[j]));//acos  important
   
   
                if(a[j].y<a[i].y) t[pl-1]=2*pi-t[pl-1];//点在下方   important
   
   
            }
   
   
            sort(t,t+pl);//极角排序
   
   
            for(int i=0;i<pl;i++) t[i+pl]=t[i]+2*pi;//important
   
   
          __int64 res=C(n-1,3);//三角形总个数
   
   
            for(int i=0,j=1;i<pl&&j<2*pl;i++)
   
   
            {
   
   
                while(t[j]-t[i]<pi) j++;
   
   
                if(j-1-i>=2) res-=C(j-1-i,2);//C(j-1-i,2) 点在三角形外面的情况
   
   
            }
   
   
            cnt-=res;//res  点在三角形里面的情况
   
   
        }
   
   
        printf("%I64d/n",cnt);
   
   
    }
   
   
    return 0;
   
   
}
  
  
  
  

   
   /*
  
  
  
  

   
   如果四个点不能组成凸四边形，则必然是其中三个点组成一个三角形，另一个点在该三角形内部。
  
  
  
  

   
   于是我们可以O(n)枚举一个点作为内部中心，试图从其他的点里选出三个来，组成三角形把它包围住，
  
  
  
  

   
   看看有多少种可能的选择。继续观察发现，如果三个点不能圈住中心点，则必然是存在一条通过中心点的直线，
  
  
  
  

   
   使得这三点都在直线的同侧。于是我们可以把所有点（除了中心点）按极角排序，然后线性转圈扫描一下就可以统计出来了。
  
  
  
  

   
   总的复杂度是O(n^2*logn)
  
  
  
  

   
   */