LA 4818 Largest Empty Circle on a Segment 开区间求并集

最新推荐文章于 2023-06-26 14:37:17 发布
最新推荐文章于 2023-06-26 14:37:17 发布
阅读量834 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： ACM_计算几何
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jingqi814/article/details/24505363

题目地址：LA4818

先尝试一下求点到线段的距离的最小值，三分圆心的位置，样例能过，不过只是巧合吧，函数不是单峰的，（求和才是，min不是）。

然后二分（所求的）半径，判断一个半径是否大了，就用每一个线段做出一个区域 ，和x轴相交，得到一个“圆心不能取的区域”。N 

然后每一个线段都对应一个“不能取的区域”，然后求并集就可以了。

值得注意的是 1 如果 交点的最小值和最大值是一个点，那么实际上不用对应取不到的区间。

                         2  端点的选取，如果 i<j   s[i].B=s[j].A 的时候，世界上是应该分为两个区间的，因为允许“touch”，那么这个公共点是允许取的。

代码：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#include<string>

const  double INF=0x3fffffff;

const  double eps=1e-10;
const double PI=acos(-1.0);

using namespace std;


struct Point{
    double x;
    double y;
    Point(double x=0,double y=0):x(x),y(y){}
    
};

int dcmp(double x)  {return (x>eps)-(x<-eps); }
int sgn(double x)  {return (x>eps)-(x<-eps); }
typedef  Point  Vector;

Vector  operator +(Vector A,Vector B) { return Vector(A.x+B.x,A.y+B.y);}

Vector  operator -(Vector A,Vector B) { return Vector(A.x-B.x,A.y-B.y); }

Vector  operator *(Vector A,double p) { return Vector(A.x*p,A.y*p);  }

Vector  operator /(Vector A,double p) {return Vector(A.x/p,A.y/p);}



ostream &operator<<(ostream & out,Point & P) { out<<P.x<<' '<<P.y; return out;}
//
bool  operator< (const Point &A,const Point &B) { return dcmp(A.x-B.x)<0||(dcmp(A.x-B.x)==0&&dcmp(A.y-B.y)<0); }



bool  operator== ( const Point &A,const Point &B) { return dcmp(A.x-B.x)==0&&dcmp(A.y-B.y)==0;}


double  Dot(Vector A,Vector B) {return A.x*B.x+A.y*B.y;}

double  Cross(Vector A,Vector B)  {return A.x*B.y-B.x*A.y; }

double  Length(Vector A)  { return sqrt(Dot(A, A));}


double  Angle(Vector A,Vector B) {return acos(Dot(A,B)/Length(A)/Length(B));}

double  Area2(Point A,Point B,Point C ) {return Cross(B-A, C-A);}

Vector Rotate(Vector A,double rad) { return Vector(A.x*cos(rad)-A.y*sin(rad),A.x*sin(rad)+A.y*cos(rad));}
Vector Normal(Vector A) {double L=Length(A);return Vector(-A.y/L,A.x/L);}

Point GetLineIntersection(Point P,Vector v,Point Q,Vector w)
{
    Vector u=P-Q;
    double t=Cross(w, u)/Cross(v,w);
    return P+v*t;
    
}

double DistanceToLine(Point P,Point A,Point B)
{
    Vector v1=P-A; Vector v2=B-A;
    return fabs(Cross(v1,v2))/Length(v2);
    
}

double DistanceToSegment(Point P,Point A,Point B)
{
    if(A==B)  return Length(P-A);
    
    Vector v1=B-A;
    Vector v2=P-A;
    Vector v3=P-B;
    
    if(dcmp(Dot(v1,v2))==-1)    return  Length(v2);
    else if(Dot(v1,v3)>0)    return Length(v3);
    
    else return DistanceToLine(P, A, B);
    
}

Point GetLineProjection(Point P,Point A,Point B)
{
    Vector v=B-A;
    Vector v1=P-A;
    double t=Dot(v,v1)/Dot(v,v);
    
    return  A+v*t;
}

bool  SegmentProperIntersection(Point a1,Point a2,Point b1,Point b2)
{
    double c1=Cross(b1-a1, a2-a1);
    double c2=Cross(b2-a1, a2-a1);
    double c3=Cross(a1-b1, b2-b1);
    double c4=Cross(a2-b1, b2-b1);
    
    return dcmp(c1)*dcmp(c2)<0&&dcmp(c3)*dcmp(c4)<0 ;
    
}

bool  OnSegment(Point P,Point A,Point B)
{
    return dcmp(Cross(P-A, P-B))==0&&dcmp(Dot(P-A,P-B))<=0;
}

bool  SegmentCommon(Point a1,Point a2,Point b1,Point b2)
{
    double c1=Cross(b1-a1, a2-a1);
    double c2=Cross(b2-a1, a2-a1);
    double c3=Cross(a1-b1, b2-b1);
    double c4=Cross(a2-b1, b2-b1);
    
    if(c1==0&&c2==0&&c3==0&&c4==0)
    {
        if(OnSegment(a1, b1, b2))  return 1;
        if(OnSegment(a2, b1, b2))  return 1;
        
        return 0;
    }
    
    return dcmp(c1)*dcmp(c2)<=0&&dcmp(c3)*dcmp(c4)<=0 ;
    
}

double PolygonArea(Point *p,int n)
{
    double area=0;
    
    for(int i=1;i<n-1;i++)
    {
        area+=Cross(p[i]-p[0], p[i+1]-p[0]);
        
    }
    return area/2;
    
}

Point  read_point()
{
    Point P;
    
    scanf("%lf%lf",&P.x,&P.y);
    
    return  P;
}

// ---------------与圆有关的--------

struct Circle
{
    Point c;
    double r;
    
    Circle(Point c=Point(0,0),double r=0):c(c),r(r) {}
    
    Point point(double a)
    {
        return Point(c.x+r*cos(a),c.y+r*sin(a));
    }
    
    
};

struct  Line
{
    Point p;
    Vector v;
    Line(Point p=Point(0,0),Vector v=Vector(0,1)):p(p),v(v) {}
    
    Point point(double t)
    {
        return Point(p+v*t);
    }
    
};

int getLineCircleIntersection(Line L,Circle C,double &t1,double &t2,vector<Point> &sol)
{
    double a=L.v.x;
    double b=L.p.x-C.c.x;
    double c=L.v.y;
    double d=L.p.y-C.c.y;
    
    double e=a*a+c*c;
    double f=2*(a*b+c*d);
    double g=b*b+d*d-C.r*C.r;
    
    double delta=f*f-4*e*g;
    
    if(dcmp(delta)<0) return 0;
    
    if(dcmp(delta)==0)
    {
        t1=t2=-f/(2*e);
        sol.push_back(L.point(t1));
        return 1;
    }
    
    else
    {
        t1=(-f-sqrt(delta))/(2*e);
        t2=(-f+sqrt(delta))/(2*e);
        
        sol.push_back(L.point(t1));
        sol.push_back(L.point(t2));
        
        return 2;
    }
    
}

// 向量极角公式

double angle(Vector v)  {return atan2(v.y,v.x);}

int getCircleCircleIntersection(Circle C1,Circle C2,vector<Point> &sol)
{
    double d=Length(C1.c-C2.c);
    
    if(dcmp(d)==0)
    {
        if(dcmp(C1.r-C2.r)==0)  return -1;  // 重合
        else return 0;    //  内含  0 个公共点
    }
    
    if(dcmp(C1.r+C2.r-d)<0)  return 0;  // 外离
    if(dcmp(fabs(C1.r-C2.r)-d)>0)  return 0;  // 内含
    
    double a=angle(C2.c-C1.c);
    double da=acos((C1.r*C1.r+d*d-C2.r*C2.r)/(2*C1.r*d));
    
    Point p1=C1.point(a-da);
    Point p2=C1.point(a+da);
    
    sol.push_back(p1);
    
    if(p1==p2)  return 1; // 相切
    else
    {
        sol.push_back(p2);
        return 2;
    }
}


//  求点到圆的切线

int getTangents(Point p,Circle C,Vector *v)
{
    Vector u=C.c-p;
    
    double dist=Length(u);
    
    if(dcmp(dist-C.r)<0)  return 0;
    
    else if(dcmp(dist-C.r)==0)
    {
        v[0]=Rotate(u,PI/2);
        return 1;
    }
    
    else
    {
        
        double ang=asin(C.r/dist);
        v[0]=Rotate(u,-ang);
        v[1]=Rotate(u,+ang);
        return 2;
    }
    
}

//  求两圆公切线


int getTangents(Circle A,Circle B,Point *a,Point *b)
{
    int cnt=0;
    
    if(A.r<B.r)
    {
        swap(A,B); swap(a, b);  //  有时需标记
    }
    
    double d=Length(A.c-B.c);
    
    double rdiff=A.r-B.r;
    double rsum=A.r+B.r;
    
    if(dcmp(d-rdiff)<0)  return 0;   // 内含
    
    double base=angle(B.c-A.c);
    
    if(dcmp(d)==0&&dcmp(rdiff)==0)   return -1 ;  // 重合 无穷多条切线
    
    if(dcmp(d-rdiff)==0)             // 内切   外公切线
    {
        a[cnt]=A.point(base);
        b[cnt]=B.point(base);
        cnt++;
        return 1;
    }
    
    // 有外公切线的情形
    
    double ang=acos(rdiff/d);
    a[cnt]=A.point(base+ang);
    b[cnt]=B.point(base+ang);
    cnt++;
    a[cnt]=A.point(base-ang);
    b[cnt]=B.point(base-ang);
    cnt++;
    
    if(dcmp(d-rsum)==0)     // 外切 有内公切线
    {
        a[cnt]=A.point(base);
        b[cnt]=B.point(base+PI);
        cnt++;
    }
    
    else  if(dcmp(d-rsum)>0)   // 外离   又有两条外公切线
    {
        double  ang_in=acos(rsum/d);
        a[cnt]=A.point(base+ang_in);
        b[cnt]=B.point(base+ang_in+PI);
        cnt++;
        a[cnt]=A.point(base-ang_in);
        b[cnt]=B.point(base-ang_in+PI);
        cnt++;
    }
    
    return cnt;
}


//  几何算法模板

int  isPointInPolygon(Point p,Point * poly,int n)
{
    int wn=0;
    for(int i=0;i<n;i++)
    {
        if(OnSegment(p, poly[i], poly[(i+1)%n]))  return -1;
        int k=dcmp(Cross(poly[(i+1)%n]-poly[i], p-poly[i]));
        int d1=dcmp(poly[i].y-p.y);
        int d2=dcmp(poly[(i+1)%n].y-p.y);
        
        if(k>0&&d1<=0&&d2>0) wn++;
        if(k<0&&d2<=0&&d1>0) wn--;
        
    }
    
    if(wn!=0)  return 1;
    else   return 0;
    
}

bool  SegmentLineIntersection(Point a1,Point a2,Point b1,Point b2)  //a1,a2 是直线  规范相交
{
    double c1=Cross(b1-a1, a2-a1);
    double c2=Cross(b2-a1, a2-a1);
    return dcmp(c1)*dcmp(c2)<=0;
}


Point ori(0,0);
Point o_X(1,0);

int n;
double L,R;

struct Segment{
    Point A;
    Point B;
    Segment(Point A=ori,Point B=ori):A(A),B(B) {}
    
};

bool seg_cmp(Segment A,Segment B)
{
    return  A.A<B.A;
    
}

Point a[2005],b[2005],a1[2005],a2[2005],b1[2005],b2[2005];

Circle C1[2005],C2[2005];
Segment s[2005];


vector<Point> inter[2005];
double  minDist(double x)
{
    Point p=Point(x,0);
    bool first=1;
    
    double ans=0;
    for(int i=0;i<n;i++)
    {
      
      if(first)
      {
          ans=DistanceToSegment(p, a[i], b[i]);
          first=0;
      }
      else
      {
          ans=min(ans,DistanceToSegment(p, a[i], b[i]));
          
      }
    }
    
    return ans;
}

vector<Segment> Union;



Line ox=Line(ori,Vector(1,0));

bool toobig(double x)
{
    // init
    //!
    for(int i=0;i<n;i++)
    {
        s[i]=Segment(ori,ori);
    }
    Union.clear();
    
    for(int i=0;i<n;i++)
    {
        inter[i].clear();
    }
    
    
    for(int i=0;i<n;i++)
    {
        C1[i].r=x;
        C2[i].r=x;
    }
    
    double t1,t2;
    for(int i=0;i<n;i++)
    {
        getLineCircleIntersection(ox,C1[i], t1, t2,inter[i]);
        getLineCircleIntersection(ox,C2[i], t1, t2,inter[i]);
        
        Vector norm=Normal(b[i]-a[i]);
       
        a1[i]=a[i]+norm*x;
        a2[i]=a[i]-norm*x;
        
        b1[i]=b[i]+norm*x;
        b2[i]=b[i]-norm*x;
    
        if(SegmentLineIntersection(ori, o_X, a1[i], b1[i]))
        {
           if(dcmp(Cross(o_X,b1[i]-a1[i]))!=0)
              {
                  Point ip=GetLineIntersection(ori, o_X, a1[i], b1[i]-a1[i]);
                  inter[i].push_back(ip);
              }
        }
        
        
        if(SegmentLineIntersection(ori, o_X, a2[i], b2[i]))
        {
            if(dcmp(Cross(o_X,b2[i]-a2[i]))!=0)
            {
                 Point ip=GetLineIntersection(ori, o_X, a2[i], b2[i]-a2[i]);
                 inter[i].push_back(ip);
            }
        }
        
        
        sort(inter[i].begin(),inter[i].end());
    
        int sz=inter[i].size();
        
        if(sz>1)
        {
            Point i_l=inter[i][0];
            Point i_r=inter[i][sz-1];
            
            s[i].A=i_l;
            s[i].B=i_r;
            
        }
        
     
        
    }
    
    s[n]=Segment(Point(-INF,0),Point(L,0));
    s[n+1]=Segment(Point(R,0),Point(INF,0));
    
    sort(s,s+n+2,seg_cmp);
    
    Union.push_back(s[0]);
    for(int i=1;i<n+2;i++)
    {
        if(s[i].A==ori&&s[i].B==ori)  continue;
        
        Segment seg=Union[Union.size()-1];
        Union.erase(Union.end()-1);
        
        if(seg.B<s[i].A||seg.B==s[i].A)
        {
            Union.push_back(seg);
            Union.push_back(s[i]);
            
        }
        
        else
        {
            Segment newseg=Segment(seg.A,max(seg.B,s[i].B));
            Union.push_back(newseg);
        }
        
    }
    
    
    if(Union.size()==1)  return 1;
    
    else  return 0;
    
}

int main()
{
  
    int T;
    cin>>T;
    while(T--)
    {
        L=0;
        cin>>n>>R;
        
     
        
        
        for(int i=0;i<n;i++)
        {
            a[i]=read_point();
            b[i]=read_point();
            C1[i].c=a[i];
            C2[i].c=b[i];
        }
        
        
        
        double l=0,r=INF;
        
        double mid;
        
        
        for(int i=0;i<50;i++)
        {
            mid=l+(r-l)/2;
            
            if(toobig(mid))
            {
                r=mid;
                
            }
            
            else l=mid;
            
            
        }
        
        printf("%.3f\n",mid);
        
    }
}


Segment Anything Model（SAM）
mingo_敏
06-25 9042
SAM，即Segment Anything，它借助了NLP任务中的Prompt思路，通过给图像分割任务提供一下Prompt提示来完成任意目标的快速分割。提示可以是前景/背景点集、粗略的框或遮罩、任意形式的文本或者任何指示图像中需要进行分割的信息。该任务的输入是原始的图像和一些提示语，输出是图片中不同目标的掩码信息。
C/C++ line segment intersection线段求交(交点)算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-18 3002
线段求交问题是计算两条线段是否相交，并求出交点的问题。线段由两个端点确定，我们需要判断两个线段是否有交点，并且求出交点的坐标。
多元函数第五：拓扑初步（2）开闭集的并和交
汪星人来地球的博客
03-07 4878
在拓扑初步（1）中，我们给出了开集和闭集的严格定义。这些定义的基础，是开球的概念。由开球，引出了内点，外点和边界点的概念。而内点，外点和边界点的集合，分别叫做内部，外部和边界。开集和闭集的概念，与边界紧密相关。如果一个集合不包含任何边界点，那么这个集合被称作开集。那么，我们可以很容易猜想，闭集就是包含所有边界点的集合。而还有许多的，介于两者之间的，包含部分边界点的集合，就既不是开集也不是闭集了。那...
uva 319 - Pendulum（几何）
不慌不忙、不急不躁
08-19 825
题目链接：uva 319 - Pendulum 注意高度不能高过水平线，一种周期是绕某点一直转圈，一种周期是返回起点。 #include #include #include #include #include using namespace std; const double pi = 4 * atan(1); const double eps = 1e-8; i
Voronoi Diagram——维诺图
weixin_30326515的博客
09-25 2997
Voronoi图定义 任意两点p 和q 之间的欧氏距离，记作 dist(p, q) 。就平面情况而言，我们有 dist(p, q) = (px-qx)2+ (py-qy)2 设P := {p1, …, pn}为平面上任意 n 个互异的点；这些点也就是基点。按照我们的定义，所谓P对应的Voronoi图，就是平面的一个子区域划分——整个平面因此被划分为n 个单元...
echarts折线图使用
十七的博客
07-21 618
echarts折线图的使用
改变拐点样式
weixin_45834859的博客
10-21 152
改变echarts图拐点样式
【论文笔记】Learning What Not to Segment: A New Perspective on Few-Shot Segmentation
栗子菜菜
07-11 2291
小样本分割新视角：学习哪些是不需要分割的
基于Segment anything的实例分割半自动标注
如果想成为中心，那么就到中心去吧。
04-17 4467
使用Meta AI的SAM，并添加了一个基本界面来标记图像，并保存COCO格式的掩码。
Fast Segment Anything Model（FastSAM）
mingo_敏
06-26 3468
Segment Anything Model（SAM）在计算机视觉任务中很有用，但它的Transformer架构在高分辨率输入下计算成本很高，限制了它在工业场景中的应用。我们提出了一种速度更快的替代方法，性能与SAM相当。通过将任务重新定义为分段生成和提示，我们发现一个常规的CNN检测器加上实例分割分支可以完成任务。我们只使用SAM作者发布的SA-1B数据集的1/50来训练现有的实例分割方法。使用我们的方法，我们在50倍运行速度下实现了与SAM相当的性能。
贪心算法区间包含
12-27
已知 n 个左闭右开区间 [ a , b) ，对其进行 m 次询问，求区间 [ l , r ] 最多可以包含 n 个区间中的多少个区间，并且被包含的所有区间都不相交。 用于贪心算法对区间包含问题的解决
CUMTOJ算法作业二
qq_41509200的博客
09-27 3808
CUMTOJ算法实验二 问题 A: 单词排序 题目描述 小红学会了很多英文单词，妈妈为了帮小红加强记忆，拿出纸、笔，把 N 个单词写在纸上的一行里，小红看了几秒钟后，将这张纸扣在桌子上。妈妈问小红：“你能否将这 N 个单词按照字典排列的顺序，从小到大写出来？”小红按照妈妈的要求写出了答案。现在请你编写程序帮助妈妈检查小红的答案是否正确。注意：所有单词都由小写字母组成，单词两两之间用一个空格分隔。 ...
echarts的简单使用(上课笔记)
qq_54061736的博客
04-20 1011
目录 一. 1.首先下载个echarts.js 2.引入echarts 3.准备一个dom容器 4.创建一个简单的饼图 5.更多的详细的配置在官方文档里都有介绍 地址:Documentation - Apache EChartshttps://echarts.apache.org/zh/option.html#title 二. 异步加载数据的时候需要导入一个jquery-2.2.4.js文件 下载地址: 1.异步加载数据画折线图 2.异步加载数据画柱状图 ...
关于一个区间分配问题
Never_More666的博客
04-23 695
public static boolean IsHave(int min,int max,String out){ String[] outs = out.split(","); List<Map<String,Integer>> list = new ArrayList<Map<String,Integer>>(); for(Stri...
echarts各个配置项详细说明总结
热门推荐
法海你不懂爱
04-20 5万+
echarts各个配置项详细说明总结最近有个朋友在做关于各种图表的项目，用到了echarts,关于各个配置项刚开始用好多都不懂，有些地方需要改不知道改哪个参数，就在网上查了各种，找到了一个不错的总结，分享给大家。（echarts官网也有配置项说明文档。）theme = { // 全图默认背景 // backgroundColor: 'rgba(0,0,0,0)', // 默认色
【计蒜客】A+B+C问题
风信子
11-05 305
题目描述 输入为一行，包括了用空格分隔的三个整数 A、B、C（数据范围均在−40 ~ 40之间）。 输出为一行，为“A+B+C”的计算结果。 样例输入 22 1 3 样例输出  26  AC代码 import java.util.Scanner; public class Main{ public static void main(String[] args){ Scanner ...
单位长度闭区间包含所有点集
onlyou2030的博客
09-21 2325
问题描述：设计一个高效算法，对实线上给定的一个点集{x1,x2,...,xn}，求一个单位长度闭区间的集合，包含所有给定的点，并要求此集合最小。证明你的算法是正确的。 思路：可以先对点集按从小到大的顺序排序，然后从最小的开始，构建单位闭区间，下一个闭区间从没有被前面闭区间覆盖的最小数开始。 时间复杂度：O(nlgn)
计蒜客比赛 - 2018 计蒜之道 初赛 第五场 A B 题解
FrozenAllen的博客
05-27 636
&lt;A&gt; 链接：https://nanti.jisuanke.com/t/27292思路：由于所有的箱子可以看成哟一个大的立方体，所有前后左右上这五个朝向各去掉一层以后，仍为立方体，那么你现在知道的是剩下多少的箱子，换句话说，已知条件是，被在五个朝向各去掉一层后的立方体的体积，那么要求原来立方体最大最小的体积分别是多少应该怎么操作呢，我的思路是，挨个枚举出来就好了，把原来的体积 V 拆成...
Empty Circle 几何 圆
ACM交流帖
08-18 357
You are given a set of n points S = {p1, p2, ..., pn} on the plane. A triple (pi, pj, pk) is called good if no point in S is strictly inside the circumference of these three points. If it is possi
Onsegment
最新发布
06-07
### Onsegment IT技术相关资料 在计算机图形学和几何算法中，`Onsegment` 通常用于描述点是否位于某条线段上的判断逻辑。这种判断是许多几何算法的基础部分，例如碰撞检测、射线交点计算等。 #### 判断点是否在线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值