2016.08.07计算几何总结测试day2

T1 bzoj: [Usaco2010 OPen]Triangle Counting 数三角形

看到这个题n那么大， 于是想到极角排序搞一搞，然而排完序后立马懵逼，完全不知道接下来应该怎么写。。。。

盯了好久题目给的图后全无思路于是手绘图，然后我就发现了秘密。。。。

极角排序后，如果两个点能与另外的某一个点构成黄金三角形，那么那个点必然在这两个点与原点连线的延长线所夹的区间内。

又因为有极角排序，点a[1],a[2]能构成的三角形，换成点a[1],a[3]肯定也可以构成，因为它们的区间一定是包含关系。

于是我们搞出所有a[i],a[i-1]区间内的答案，计算对答案的贡献即可。

正着有i-1个区间包含它，反着有n-i个区间包含它，然后搞一搞就好了。。。

细节什么的参见代码，反正感觉我代码是写丑了，我还算出了j搞了两遍for循环，看他们代码一个个巨短。。。。理应一遍就应该可以了吧。。。。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 #define maxn 100100
 #define pi (acos(-1.0))

 int n,j,tmp,sum;
 long long ans;

 struct point{
     double x,y,ang;
 }p[maxn];

 double operator *(point a,point b){return a.x*b.y-a.y*b.x;}

 bool cmp(point a,point b){
     return a.ang<b.ang;
 }

 int main(){
 //  freopen("input.txt","r",stdin);
 //  freopen("output.txt","w",stdout);
     scanf("%d",&n);
     for (int i=;i<=n;i++)
         scanf("%lf%lf",&p[i].x,&p[i].y),p[i].ang=atan2(p[i].y,p[i].x);
     sort(p+,p+n+,cmp);
     for (int i=;i<=n;i++) if (p[i].ang-p[].ang>pi){j=tmp=i;break;}
     for (int i=;i<j;i++){
         int sum=;
         while (p[tmp].ang-p[i].ang<pi && tmp<=n) tmp++,sum++;
         ans+=(long long)sum*(i-)*(j-i);
     }
     for (int i=;i<j;i++) if (p[j].ang-p[i].ang<pi){tmp=i;break;}
     for (int i=j+;i<=n;i++){
         int sum=;
         while (p[i].ang-p[tmp].ang>pi && tmp<j) tmp++,sum++;
         ans+=(long long)sum*(i-j)*(n-i+);
     }
     printf("%lld\n",ans);
     return ;
 }

T1

T2 poj 3608 Bridge Across Islands

两个多边形间的旋转卡壳，网上给了一大堆代码，一大堆题解，感觉都大同小异，几乎都是国外某大牛的论文翻译过来的。。。。。什么搞出一个ymin，ymax，特别是哪个叉乘while，根本看不懂。。。。。线段之间的距离真的可以用叉乘吗。。。。。（蒟蒻求解。。。）

于是我有一种想法，首先在多边形P上随便找到一条边，然后找到多边形Q上距离最近的点，然后将多边形P上的该边跳到它的邻边，同时直接移动多边形Q上找到的点，和两边的点比较，之后移动，直到移动到下一个点的距离比该点距离大就停止。然后在多边形Q上也做一次类似的即可。然后每次移动更新答案，就完了。。。。。

感觉这样做正确性也十分显然，因为对于任意一条边，另一个多边形的所有点距离它都是单峰的。于是对于当前点，它一定能找到距离最近的点。注意这里并不用两个指针扫，只需要将当前点与左右两边比较就行了。因为不可能出现左右两边的点都比当前点更优的情况，因为当前点一定是左右两边的某个点转移过来的，而对于当前的边，它一定会比至少一条边优。（这个性质稍微分情况讨论一下也可以得出），同时因为边每次只是跳到邻边，因此绝对不会出现每次移动n/2的情况，因为这个过程类似于旋转卡壳实现过程，时间复杂度也是可以保证的，常数好像大了一些。。。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 #define maxn 100010
 #define inf 1e9

 int n,m;
 double ans;

 struct point{
     double x,y;
 }p[maxn],q[maxn];

 struct line{
     point from,to;
 }lp[maxn],lq[maxn];

 point operator -(point a,point b){return (point){a.x-b.x,a.y-b.y};}
 double operator *(point a,point b){return a.x*b.y-a.y*b.x;}

 double sqr(double x){return x*x;}
 double dis(point a,point b){return sqr(a.x-b.x)+sqr(a.y-b.y);}

 double point_line_dis(point a,line b){
     if (dis(b.to,b.from)+min(dis(a,b.to),dis(a,b.from))<max(dis(a,b.to),dis(a,b.from)))
     return sqrt(min(dis(a,b.to),dis(a,b.from)));
     else return fabs((b.to-a)*(b.from-a))/sqrt(dis(b.to,b.from));
 }

 void solvep(){
     double dist=inf;int pos;
     for (int i=;i<=m;i++){
         double tmp=point_line_dis(q[i],lp[]);
         if (tmp<dist)
             dist=tmp,pos=i;
     }
     ans=min(ans,dist);
     for (int i=;i<=n;i++){
         while (point_line_dis(q[pos],lp[i])>point_line_dis(q[pos+],lp[i])) pos==m?pos=:pos++;
         while (point_line_dis(q[pos],lp[i])>point_line_dis(q[pos-],lp[i])) pos==?pos=m:pos--;
         ans=min(ans,point_line_dis(q[pos],lp[i]));
     }
 }

 void solveq(){
     double dist=inf;int pos;
     for (int i=;i<=n;i++){
         double tmp=point_line_dis(p[i],lq[]);
         if (tmp<dist)
             dist=tmp,pos=i;
     }
     ans=min(ans,dist);
     for (int i=;i<=m;i++){
         while (point_line_dis(p[pos],lq[i])>point_line_dis(p[pos+],lq[i])) pos==n?pos=:pos++;
         while (point_line_dis(p[pos],lq[i])>point_line_dis(p[pos-],lq[i])) pos==?pos=n:pos--;
         ans=min(ans,point_line_dis(p[pos],lq[i]));
     }
 }

 int main(){
     while (scanf("%d%d",&n,&m)!=EOF){
         ans=inf;
         if (n== && m==) break;
         for (int i=;i<=n;i++) scanf("%lf%lf",&p[i].x,&p[i].y);
         for (int i=;i<=m;i++) scanf("%lf%lf",&q[i].x,&q[i].y);
         p[n+]=p[],q[m+]=q[];
         for (int i=;i<=n;i++) lp[i].from=p[i],lp[i].to=p[i+];
         for (int i=;i<=m;i++) lq[i].from=q[i],lq[i].to=q[i+];
         solvep();
         solveq();
         printf("%.6f\n",ans);
     }
     return ;
 }

T2

T3 一道不知道哪里可以交的题目

题目大意：平面内有n个点，p1,p2,p3...pn。在平面内选m个点，并将p[]分成m段区间，定义d为每一段区间内的点p与找到的点q的距离的最大值，让所有区间d的最大值最小，并输出这个d。

看到最大值最小，考虑二分，二分这个答案d，然后考虑如何去check。

其次可以考虑贪心，因为已经得出了这个d，然后让这个区间内的所有点到找到的点的距离都不超过d，可以考虑最小圆覆盖，如果当前点在已经得到的圆内，就直接加，否则得到新的圆，如果新的圆的半径大于了这个二分的d，就可以新分一段，再去做最小圆覆盖，如果段数要大于m，就可以return 0了。

但以保证最小圆覆盖的复杂度必须要random_shuffle()，所以check()不能直接二分+最小圆覆盖，这样复杂度会爆炸，可以用倍增把二分的范围卡在logn之内再上二分就能（卡）过了。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 #define maxn 100010
 #define inf 2000000
 #define double long double
 const double eps=1e-;

 int n,m;

 struct point{
     double x,y,r;
 }a[maxn],b[maxn],O;

 double sqr(double x){return x*x;}
 double dis(point a,point b){return sqr(a.x-b.x)+sqr(a.y-b.y);}

 void getcircle(int i,int j){
     O.r=dis(b[i],b[j])/;
     O.x=(b[i].x+b[j].x)/;
     O.y=(b[i].y+b[j].y)/;
 }

 void getcircle(int i,int j,int k){
     double a,c,d,e,f,g;
     a=*(b[i].x-b[j].x);
     g=*(b[i].y-b[j].y);
     c=sqr(b[i].x)-sqr(b[j].x)+sqr(b[i].y)-sqr(b[j].y);
     d=*(b[i].x-b[k].x);
     e=*(b[i].y-b[k].y);
     f=sqr(b[i].x)-sqr(b[k].x)+sqr(b[i].y)-sqr(b[k].y);
     O.x=(c*e-g*f)/(a*e-g*d);
     O.y=(c*d-a*f)/(g*d-a*e);
     O.r=dis(O,b[i]);
 }

 bool incircle(int i){
     return dis(b[i],O)-O.r<=eps;
 }

 bool judgecircle(int l,int r,double limit){
 //    if (l==r) return 1;
     int cnt=;
     for (int i=l;i<=r;i++) b[++cnt]=a[i];
     random_shuffle(b+,b+cnt+);
     getcircle(,);
     if (O.r>sqr(limit)+eps) return ;
     for (int i=;i<=cnt;i++)
         if (!incircle(i)){
             getcircle(,i);
             if (O.r>sqr(limit)+eps) return ;
             for (int j=;j<i;j++)
                 if (!incircle(j)){
                     getcircle(i,j);
                     if (O.r>sqr(limit)+eps) return ;
                     for (int k=;k<j;k++)
                         if (!incircle(k)){
                             getcircle(i,j,k);
                             if (O.r>sqr(limit)+eps) return ;
                         }
                 }
         }
     return ;
 }

 bool check(double limit){
     int pos=,num=;
     for (int i=;i<=n;i=pos+){
         int len=;
         while (i+(len<<)-<=n && judgecircle(i,i+(len<<)-,limit)) len<<=;
         int l=i+len-,r=min(i+(len*)-,n);
         while (l<r){
             int mid=(l+r)>>;
             if (judgecircle(i,mid+,limit)) l=mid+;
             else r=mid;
         }
         pos=r,num++;
         if (num>m) return ;
     }
     return ;
 }

 int main(){
 //    freopen("input.txt","r",stdin);
 //    freopen("output.txt","w",stdout);
     scanf("%d%d",&n,&m);
     for (int i=;i<=n;i++)
         scanf("%Lf%Lf",&a[i].x,&a[i].y);
     double l=,r=inf;
     while (l+1e-<=r){
         double mid=(l+r)/;
         if (check(mid)) r=mid;
         else l=mid;
     }
     printf("%.6Lf\n",l);
     return ;
 }

T3