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=1;i<=n;i++)
        scanf("%lf%lf",&p[i].x,&p[i].y),p[i].ang=atan2(p[i].y,p[i].x);
    sort(p+1,p+n+1,cmp);
    for (int i=1;i<=n;i++) if (p[i].ang-p[1].ang>pi){j=tmp=i;break;}
    for (int i=2;i<j;i++){
        int sum=0;
        while (p[tmp].ang-p[i].ang<pi && tmp<=n) tmp++,sum++;
        ans+=(long long)sum*(i-1)*(j-i);
    }
    for (int i=1;i<j;i++) if (p[j].ang-p[i].ang<pi){tmp=i;break;}
    for (int i=j+1;i<=n;i++){
        int sum=0;
        while (p[i].ang-p[tmp].ang>pi && tmp<j) tmp++,sum++;
        ans+=(long long)sum*(i-j)*(n-i+1);
    }
    printf("%lld
",ans);
    return 0;
}

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=1;i<=m;i++){
        double tmp=point_line_dis(q[i],lp[1]);
        if (tmp<dist)
            dist=tmp,pos=i;
    }
    ans=min(ans,dist);
    for (int i=2;i<=n;i++){
        while (point_line_dis(q[pos],lp[i])>point_line_dis(q[pos+1],lp[i])) pos==m?pos=1:pos++;
        while (point_line_dis(q[pos],lp[i])>point_line_dis(q[pos-1],lp[i])) pos==1?pos=m:pos--;
        ans=min(ans,point_line_dis(q[pos],lp[i]));
    }
}

void solveq(){
    double dist=inf;int pos;
    for (int i=1;i<=n;i++){
        double tmp=point_line_dis(p[i],lq[1]);
        if (tmp<dist)
            dist=tmp,pos=i;
    }
    ans=min(ans,dist);
    for (int i=2;i<=m;i++){
        while (point_line_dis(p[pos],lq[i])>point_line_dis(p[pos+1],lq[i])) pos==n?pos=1:pos++;
        while (point_line_dis(p[pos],lq[i])>point_line_dis(p[pos-1],lq[i])) pos==1?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==0 && m==0) break;
        for (int i=1;i<=n;i++) scanf("%lf%lf",&p[i].x,&p[i].y);
        for (int i=1;i<=m;i++) scanf("%lf%lf",&q[i].x,&q[i].y);
        p[n+1]=p[1],q[m+1]=q[1];
        for (int i=1;i<=n;i++) lp[i].from=p[i],lp[i].to=p[i+1];
        for (int i=1;i<=m;i++) lq[i].from=q[i],lq[i].to=q[i+1];
        solvep();
        solveq();
        printf("%.6f
",ans);
    }
    return 0;
}

 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-9;
 
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])/4;
    O.x=(b[i].x+b[j].x)/2;
    O.y=(b[i].y+b[j].y)/2;
}
 
void getcircle(int i,int j,int k){
    double a,c,d,e,f,g;
    a=2*(b[i].x-b[j].x);
    g=2*(b[i].y-b[j].y);
    c=sqr(b[i].x)-sqr(b[j].x)+sqr(b[i].y)-sqr(b[j].y);
    d=2*(b[i].x-b[k].x);
    e=2*(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=0;
    for (int i=l;i<=r;i++) b[++cnt]=a[i];
    random_shuffle(b+1,b+cnt+1);
    getcircle(1,2);
    if (O.r>sqr(limit)+eps) return 0;
    for (int i=3;i<=cnt;i++)
        if (!incircle(i)){
            getcircle(1,i);
            if (O.r>sqr(limit)+eps) return 0;
            for (int j=2;j<i;j++)
                if (!incircle(j)){
                    getcircle(i,j);
                    if (O.r>sqr(limit)+eps) return 0;
                    for (int k=1;k<j;k++)
                        if (!incircle(k)){
                            getcircle(i,j,k);
                            if (O.r>sqr(limit)+eps) return 0;
                        }
                }
        }
    return 1;
}
 
bool check(double limit){
    int pos=0,num=0;
    for (int i=1;i<=n;i=pos+1){
        int len=1;
        while (i+(len<<1)-1<=n && judgecircle(i,i+(len<<1)-1,limit)) len<<=1;
        int l=i+len-1,r=min(i+(len*2)-1,n);
        while (l<r){
            int mid=(l+r)>>1;
            if (judgecircle(i,mid+1,limit)) l=mid+1;
            else r=mid;
        }
        pos=r,num++;
        if (num>m) return 0;
    }
    return 1;
}
 
int main(){
//    freopen("input.txt","r",stdin);
//    freopen("output.txt","w",stdout);
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
        scanf("%Lf%Lf",&a[i].x,&a[i].y);
    double l=0,r=inf;
    while (l+1e-7<=r){
        double mid=(l+r)/2;
        if (check(mid)) r=mid;
        else l=mid;
    }
    printf("%.6Lf
",l);
    return 0;
}