BZOJ 2280 Poi2011 Plot 二分答案+随机增量法
题目大意：给定n个点，要求分成m段，使每段最小覆盖圆半径的最大值最小
二分答案，然后验证的时候把点一个个塞进最小覆盖圆中，若半径超了就分成一块……
等等你在跟我说不随机化的随机增量法？
好吧
那么对于一个点pos，我们要计算最大的bound满足[pos,bound]区间内的最小覆盖圆半径不超过二分的值
直接上二分是不可取的，因为我们要求m次，如果每次都验证一遍[1,n/2]直接就炸了
我们可以这么搞
首先判断[pos,pos+1-1]是否满足要求
然后判断[pos,pos+2-1]是否满足要求
然后判断[pos,pos+4-1]是否满足要求
然后判断[pos,pos+8-1]是否满足要求
...
直到找到一个不满足要求2^k的为止，然后我们在[2^(k-1),2^k]区间内二分
这样可以保证复杂度为O(nlognlog(limit/eps)) 不过常数巨大。。。。
居然直接A了 没卡掉OJ真是差评
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
#define M 100100
#define EPS 1e-10
using namespace std;
typedef long double ld;
struct Point{
ld x,y;
Point() {}
Point(ld _,ld __):
x(_),y(__) {}
friend istream& operator >> (istream &_,Point &p)
{
double x,y;
scanf("%lf%lf",&x,&y);
p.x=x;p.y=y;
return _;
}
friend Point operator + (const Point &p1,const Point &p2)
{
return Point(p1.x+p2.x,p1.y+p2.y);
}
friend Point operator - (const Point &p1,const Point &p2)
{
return Point(p1.x-p2.x,p1.y-p2.y);
}
friend ld operator * (const Point &p1,const Point &p2)
{
return p1.x*p2.y-p1.y*p2.x;
}
friend Point operator * (const Point &p,ld rate)
{
return Point(p.x*rate,p.y*rate);
}
friend ld Distance(const Point &p1,const Point &p2)
{
return sqrt( (p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y) ) ;
}
friend Point Rotate(const Point &p)
{
return Point(-p.y,p.x);
}
}points[M];
struct Line{
Point p,v;
Line() {}
Line(const Point &_,const Point &__):
p(_),v(__) {}
friend Point Get_Intersection(const Line &l1,const Line &l2)
{
Point u=l1.p-l2.p;
ld temp=(l2.v*u)/(l1.v*l2.v);
return l1.p+l1.v*temp;
}
};
struct Circle{
Point o;
ld r;
Circle() {}
Circle(const Point &_,ld __):
o(_),r(__) {}
bool In_Circle(const Point &p)
{
return Distance(p,o) < r + EPS ;
}
};
int n,m;
Circle Min_Circle_Cover(int l,int r)
{
static Point points[M];
int i,j,k;
Circle ans(Point(0,0),0);
memcpy(points+l,::points+l,sizeof(Point)*(r-l+1));
random_shuffle(points+l,points+r+1);
for(i=l;i<=r;i++)
if(!ans.In_Circle(points[i]))
{
ans=Circle(points[i],0);
for(j=l;j<i;j++)
if(!ans.In_Circle(points[j]))
{
ans=Circle((points[i]+points[j])*0.5,Distance(points[i],points[j])*0.5);
for(k=l;k<j;k++)
if(!ans.In_Circle(points[k]))
{
Line l1=Line((points[i]+points[j])*0.5,Rotate(points[i]-points[j]));
Line l2=Line((points[i]+points[k])*0.5,Rotate(points[i]-points[k]));
Point p=Get_Intersection(l1,l2);
ans=Circle(p,Distance(p,points[i]));
}
}
}
return ans;
}
int Extend(int pos,ld limit)
{
int i;
for(i=1;;i=min(i<<1,n-pos+1))
{
if(Min_Circle_Cover(pos,pos+i-1).r>limit+EPS)
break;
if(i==n-pos+1) return n;
}
int l=pos+(i>>1)-1,r=pos+i-1;
while(l+1<r)
{
int mid=l+r>>1;
if(Min_Circle_Cover(pos,mid).r<limit+EPS)
l=mid;
else
r=mid;
}
return l;
}
bool Judge(ld limit)
{
int i,last,cnt=0;
for(i=1;i<=n;i=last+1)
{
if(++cnt==m+1)
return false;
last=Extend(i,limit);
}
return true;
}
ld Bisection()
{
ld l=0,r=Min_Circle_Cover(1,n).r;
while(r-l>EPS)
{
ld mid=(l+r)/2;
if( Judge(mid) )
r=mid;
else
l=mid;
}
return r;
}
void Output(double limit)
{
static Point stack[M];
int i,last,top=0;
for(i=1;i<=n;i=last+1)
{
last=Extend(i,limit);
stack[++top]=Min_Circle_Cover(i,last).o;
}
cout<<top<<endl;
for(i=1;i<=top;i++)
printf("%.15lf %.15lf\n",(double)stack[i].x,(double)stack[i].y);
}
int main()
{
int i;
cin>>n>>m;
for(i=1;i<=n;i++)
cin>>points[i];
ld ans=Bisection();
cout<<fixed<<setprecision(15)<<ans<<endl;
Output(ans+EPS);
return 0;
}