Hdu 4667 Building Fence

最新推荐文章于 2016-11-23 19:19:09 发布
最新推荐文章于 2016-11-23 19:19:09 发布
阅读量919 收藏
点赞数 2
分类专栏： 计算几何——二维 文章标签： acm 计算几何 二维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wty__/article/details/12911951
版权

Building Fence

这个题有两种解法:

方法一:将圆均分2000个点,暴力水过

程序简单,好写

精度要求比较高,无从下手的时候可以尝试一下,一旦精度要求比较高不过的可能性比较大...

交c++超时,g++800+ms,表示不理解

const int INF = 1000000000;
const double eps = 1e-10;
const int MOD = 100000007;
const int MAXN = 10000000;
const double PI = acos(-1.0);


///*************基础***********/
inline int dcmp(double x)
{
    if(fabs(x) < eps) return 0;
    else return x < 0 ? -1 : 1;
}
struct Point
{
    double x, y;
    Point(double x=0, double y=0):x(x),y(y) { }
    inline void read() { scanf("%lf%lf", &x, &y); }
};
typedef vector<Point> Polygon;

typedef Point Vector;

inline Vector operator + (Vector A, Vector B) { return Vector(A.x+B.x, A.y+B.y); }
inline Vector operator - (Point A, Point B) { return Vector(A.x-B.x, A.y-B.y); }
inline Vector operator * (Vector A, double p) { return Vector(A.x*p, A.y*p); }
inline Vector operator / (Vector A, double p) { return Vector(A.x/p, A.y/p); }

inline bool operator < (const Point& a, const Point& b)
{
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}

inline bool operator == (const Point& a, const Point &b)
{
    return dcmp(a.x-b.x) == 0 && dcmp(a.y-b.y) == 0;
}

inline double Dot(Vector A, Vector B)
{
    return A.x*B.x + A.y*B.y;
}
inline double Length(Vector A)
{
    return sqrt(Dot(A, A));
}
inline double Angle(Vector A, Vector B)
{
    return acos(Dot(A, B) / Length(A) / Length(B));
}
inline double angle(Vector v)
{
    return atan2(v.y, v.x);
}
inline double Cross(Vector A, Vector B)
{
    return A.x*B.y - A.y*B.x;
}
inline Vector vecunit(Vector x)
{
    return x / Length(x);   //单位向量
}
inline Vector Normal(Vector x)
{
    return Point(-x.y, x.x) / Length(x);   //垂直法向量
}
inline 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<Point> ConvexHull(vector<Point>& p)
{
    // 预处理，删除重复点
    sort(p.begin(), p.end());
    p.erase(unique(p.begin(), p.end()), p.end());

    int n = p.size();
    int m = 0;
    vector<Point> ch(n+1);
    for(int i = 0; i < n; i++)
    {
        while(m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
        ch[m++] = p[i];
    }
    int k = m;
    for(int i = n-2; i >= 0; i--)
    {
        while(m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
        ch[m++] = p[i];
    }
    if(n > 1) m--;
    ch.resize(m);
    return ch;
}


inline double dist(Point a, Point b)
{
    return Length(a - b);
}


/************圆************/
struct Circle
{
    Point c;
    double r;
    Circle() {}
    Circle(Point c, double r):c(c), r(r) {}
    inline Point point(double a) //根据圆心角求点坐标
    {
        return Point(c.x+cos(a)*r, c.y+sin(a)*r);
    }
};


vector<Point> p, ans;
const double interval = PI / 1000;

int main()
{
//    freopen("0.txt", "r", stdin);
    int N, M, size;
    Point input;
    double r, tx, ty, dis, ang;
    while (~RII(N, M))
    {
        ans.clear(), p.clear();
        dis = 0;
        REP(i, N)
        {
            scanf("%lf%lf%lf", &tx, &ty, &r);
            for (double ang = 0; ang < 2 * PI; ang += interval)
            {
                input.x = tx + cos(ang) * r;
                input.y = ty + sin(ang) * r;
                p.push_back(input);
            }
        }
        REP(i, M)
        {
            input.read();
            p.push_back(input);
            input.read();
            p.push_back(input);
            input.read();
            p.push_back(input);
        }
        ans = ConvexHull(p);
        size = ans.size();
        REP(i, size - 1)
        {
            dis += Length(ans[i] - ans[i + 1]);
        }
        dis += dist(ans[size - 1], ans[0]);
        printf("%.5lf\n", dis);
    }
    return 0;
}

方法二:

将有可能构成凸包的点计算出来,包括 三角形的顶点,三角形顶点与各个圆的切点,任意两个圆的切点 

然后计算凸包即可

有两个要注意的地方,第一是求凸包边长时候,需要判断一下当前计算的两个点是否在同一个圆上,若是则需要计算圆弧长度

                                     第二是只有一个圆的时候需要特判

const int INF = 0x3f3f3f3f;
const double eps = 1e-10;
const int MOD = 100000007;
const int MAXN = 1000010;
const double PI = acos(-1.0);


///*************基础***********/
double torad(double deg)
{
    return deg / 180 * PI;
}
inline int dcmp(double x)
{
    if(fabs(x) < eps) return 0;
    else return x < 0 ? -1 : 1;
}
struct Point
{
    double x, y;
    Point(double x=0, double y=0):x(x),y(y) { }
    inline void read()
    {
        scanf("%lf%lf", &x, &y);
    }
};
typedef vector<Point> Polygon;
typedef Point Vector;

inline Vector operator + (Vector A, Vector B)
{
    return Vector(A.x+B.x, A.y+B.y);
}
inline Vector operator - (Point A, Point B)
{
    return Vector(A.x-B.x, A.y-B.y);
}
inline Vector operator * (Vector A, double p)
{
    return Vector(A.x*p, A.y*p);
}
inline Vector operator / (Vector A, double p)
{
    return Vector(A.x/p, A.y/p);
}


inline bool operator < (Point a, Point b)
{
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}


inline bool operator == (Point a, Point b)
{
    return dcmp(a.x-b.x) == 0 && dcmp(a.y-b.y) == 0;
}


inline double Dot(Vector A, Vector B)
{
    return A.x*B.x + A.y*B.y;
}
inline double Length(Vector A)
{
    return sqrt(Dot(A, A));
}
inline double Angle(Vector A, Vector B)
{
    return acos(Dot(A, B) / Length(A) / Length(B));
}
inline double angle(Vector v)
{
    return atan2(v.y, v.x);
}
inline double Cross(Vector A, Vector B)
{
    return A.x*B.y - A.y*B.x;
}
inline Vector Unit(Vector x)
{
    return x / Length(x);   //单位向量
}
inline Vector Normal(Vector x)
{
    return Point(-x.y, x.x) / Length(x);   //垂直法向量
}
inline Vector Rotate(Vector A, double rad)
{
    return Vector(A.x*cos(rad)-A.y*sin(rad), A.x*sin(rad)+A.y*cos(rad));
}
inline double Area2(Point A, Point B, Point C)
{
    return Cross(B-A, C-A);
}

template <class T> T sqr(T x)
{
    return x * x ;
}

// 点集凸包
// 如果不希望在凸包的边上有输入点，把两个 <= 改成 <
// 注意：输入点集会被修改
vector<Point> ConvexHull(vector<Point>& p)
{
    // 预处理，删除重复点
    sort(p.begin(), p.end());
    p.erase(unique(p.begin(), p.end()), p.end());


    int n = p.size();
    int m = 0;
    vector<Point> ch(n+1);
    for(int i = 0; i < n; i++)
    {
        while(m > 1 && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
        ch[m++] = p[i];
    }
    int k = m;
    for(int i = n-2; i >= 0; i--)
    {
        while(m > k && Cross(ch[m-1]-ch[m-2], p[i]-ch[m-2]) <= 0) m--;
        ch[m++] = p[i];
    }
    if(n > 1) m--;
    ch.resize(m);
    return ch;
}




inline double dist(Point a, Point b)
{
    return Length(a - b);
}

/************圆************/
struct Circle
{
    Point c;
    double r;
    Circle() {}
    Circle(Point c, double r):c(c), r(r) {}
    inline Point point(double a) //根据圆心角求点坐标
    {
        return Point(c.x+cos(a)*r, c.y+sin(a)*r);
    }
    inline void read()
    {
        scanf("%lf%lf%lf", &c.x, &c.y, &r);
    }
};

//求a点到b点(逆时针)在的圆上的圆弧长度
double DisOnCircle(Point a, Point b, Circle C)
{
    double ang1 = angle(a - C.c);
    double ang2 = angle(b - C.c);
    if (ang2 < ang1) ang2 += 2 * PI;
    return C.r * (ang2 - ang1);
}

// 过点p到圆C的切点
int getTangentPoints(Point p, Circle C, vector<Point>& v)
{
    Vector u = C.c - p;
    double dist = Length(u);
    if(dist < C.r) return 0;
    else if(dcmp(dist - C.r) == 0)   // p在圆上，只有一条切线
    {
        v.push_back(p);
        return 1;
    }
    else
    {
        double ang = asin(C.r / dist);
        double d = sqrt(dist * dist - C.r * C.r);
        v.push_back(p + Unit(Rotate(u, -ang)) * d);
        v.push_back(p + Unit(Rotate(u, +ang)) * d);
        return 2;
    }
}

//圆A与圆B的切点
void getTangentPoints(Circle A, Circle B, vector<Point>& a)
{
    if (A.r < B.r) swap(A, B);
    ///****************************
    int d2 = sqr(A.c.x - B.c.x) + sqr(A.c.y - B.c.y);
    int rdiff = A.r - B.r, rsum = A.r + B.r;
    if (d2 < rdiff * rdiff) return;   //内含

    ///***************************************
    double base = atan2(B.c.y - A.c.y, B.c.x - A.c.x);
    if (d2 == 0 && A.r == B.r) return;    //无线多条切线
    if (d2 == rdiff * rdiff)    //内切, 1条切线
    {
        ///**********************
        a.push_back(A.point(base));
        a.push_back(B.point(base));
        return;
    }
    //有外公切线
    double ang = acos((A.r - B.r) / sqrt(d2 * 1.0));
    a.push_back(A.point(base + ang)); a.push_back(B.point(base + ang));
    a.push_back(A.point(base - ang)); a.push_back(B.point(base - ang));
    if (d2 == rsum * rsum)  //一条内公切线
    {
        a.push_back(A.point(base));
        a.push_back(B.point(PI + base));
    }
    else if (d2 > rsum * rsum)  //两条内公切线
    {
        double ang = acos((A.r + B.r) / sqrt(d2 * 1.0));
        a.push_back(A.point(base + ang));
        a.push_back(B.point(PI + base + ang));
        a.push_back(A.point(base - ang));
        a.push_back(B.point(PI + base - ang));
    }
}



inline bool OnCircle(Point x, Circle c)
{
    return dcmp(c.r - Length(c.c - x)) == 0;
}


Circle C[60];
Point P[160];
vector<Point> ch, sol;
double t1, t2;
int main()
{
    int a, b;
    while (~RII(a, b))
    {
        ch.clear(), sol.clear();

        REP(i, a) C[i].read();
        b *= 3;
        REP(i, b)
        {
            P[i].read();
            sol.push_back(P[i]);
        }
        REP(i, b) REP(j, a)
        {
            getTangentPoints(P[i], C[j], sol);
        }
        FF(i, 0, a) FF(j, i + 1, a)
        {
            getTangentPoints(C[i], C[j], sol);
        }
        ch = ConvexHull(sol);
        double ans = 0;
        int len = ch.size();
        REP(i, len)
        {
            REP(j, a)
            {
                if (OnCircle(ch[i], C[j]) && OnCircle(ch[(i + 1) % len], C[j]))
                {
                    ans += DisOnCircle(ch[i], ch[(i + 1) % len], C[j]);
                    goto end;
                }
            }
            ans += dist(ch[i], ch[(i + 1) % len]);
            end:;
        }
        if (a == 1 && b == 0)
            ans += 2 * PI * C[0].r;
        printf("%.5lf\n", ans);
    }
    return 0;
}



_hehe_
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
building boundary extraction algorithm
03-27
An improved building boundary extraction algorithm based on fusion of optical Imagery and LIDAR data
【枚举】UPC Contest2575 - 2020年秋季组队训练赛第八场 问题 B: Building Boundaries
小明的博客
09-15 264
问题 B: Building Boundaries 时间限制: 1Sec1 Sec1Sec 内存限制: 128MB128 MB128MB 题目描述 Maarja wants to buy a rectangular piece of land and then construct three buildings on that land. The boundaries of the buildings on the ground must have rectangular sizes a1 × b1 ,
Building Coder（Revit 二次开发）- 关于楼板边界的重新思考
摘花换酒的专栏
10-12 5918
原文链接：Slab Boundary Revisited 问题 如何使用 Revit API 获取楼板边界？ Jeremy 我2008年时就实现了一个名为 CmdSlabBoundary 的外部命令用于获取楼板边界。这个命令识别一块楼板的边界（包括门洞），然后沿着边界创建一组高亮的模型曲线。 针对你的问题，我重新检查了这个命令，并将其代码更新到 Revit 2013。 [T
终于过了- - ACM-POJ3253 Fence Repair(中文版是搬水果)
AC_dream
01-25 980
Fence Repair Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 28327 Accepted: 9199 Description Farmer John wants to repair a small length of the fence around the pasture. He measures
hdu 4667 Building Fence
08-15 639
给出n个圆和m个三角形，然后用篱笆把它们围起来，问需要最短的篱笆长度是多少。 这题标称应该是求出每个三角形的每个顶点与每个圆的切点和两两圆之间的切点，然后切点来做凸包，最后把凸包上的点的距离加起来，注意在一个圆上两个点的距离是他们的 弧长，我做的时候就直接暴力了，把每个圆拆点，然后把所有点再来做凸包，最后求距离和 #include #include #include #include #in
HDU 4667 Building Fence
青竹梦
08-16 1142
题意： 给n个圆和m个三角形，且保证互不相交，用一个篱笆把他们围起来，求最短的周长是多少。 做法：--水过。。。 把一个圆均匀的切割成500个点，然后求凸包。 注意：求完凸包，在求周长的时候记得要把圆的那部分特殊求。 sin（x）  x=PI*（i/j）；//度数表示的时候用PI； #include #include #include #include #def
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
bfs.rar_hdu
09-22
题目“bfs.rar_hdu”暗示了这是一个关于广度优先搜索（Breadth-First Search, BFS）的问题，源自HDU（杭州电子科技大学）的在线编程竞赛平台。通常，这类题目会涉及图论或者树的遍历，考察算法实现和逻辑思维能力。 ...
Rightmost Digit_hdu_
10-03
【标题】"Rightmost Digit HDU" 这道题目来源于HDU（杭州电子科技大学）的在线判题系统，通常这类题目是编程竞赛或者算法训练的一部分。"Rightmost Digit"直译为“最右边的数字”，我们可以推测这是一个关于数字...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
poj_2187 Beauty Contest（凸包+旋转卡壳）
凳子
11-23 340
Beauty Contest Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 35711   Accepted: 11066 Description Bessie, Farmer John's prize cow, has just won first place in
模板——多圆相交的公共面积
Confidence的专栏
10-17 2591
main函数中只要调用solve（）就好了，solve函数中的n即代表n个圆，先输入n，再输入n个圆的圆心坐标和半径，直接在函数中输出多圆相交的公共面积
模板——两个圆相交的公共面积
Confidence的专栏
10-17 1555
模板——两个圆相交的公共面积
A Star not a Tree?
Confidence的专栏
06-11 1503
给n个点，求费马点到各点的距离和
Pan's Labyrinth
Confidence的专栏
03-05 1332
分析出来三角形的底可以是任意两个点组成，但是对应的最优高的第三个点一定在凸包上，那么就可以在凸包上进行旋转卡壳，整体复杂度为O(n * n * log(n))
hdu 1007_平面最近点对模板
Confidence的专栏
10-25 1289
简单题目,直接模板上 http://acm.hdu.edu.cn/showproblem.php?pid=1007   Quoit Design #include #include #include #include #include #include #include #include #include #include #include #include
hdu 2297 run
最新发布
06-21
HDOJ（ HDU Online Judge）是一个知名的中文编程题库和在线评测系统，题号2297的题目通常会有一个具体的名字，没有直接提供，所以我无法给你详细介绍“run”。不过，我可以给你一般性的描述和可能涉及的编程知识点。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值