简单几何(直线与圆的交点) ZOJ Collision 3728

题目传送门

题意:有两个一大一小的同心圆,圆心在原点,大圆外有一小圆,其圆心有一个速度(vx, vy),如果碰到了小圆会反弹,问该圆在大圆内运动的时间

分析:将圆外的小圆看成一个点,判断该直线与同心圆的交点,根据交点个数计算时间。用到了直线的定义,圆的定义,直线与圆交点的个数。

/************************************************
* Author        :Running_Time
* Created Time  :2015/10/24 星期六 16:14:33
* File Name     :C.cpp
 ************************************************/

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <bitset>
#include <cstdlib>
#include <ctime>
using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
typedef long long ll;
const int N = 1e5 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-10;
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) {}
    Point operator + (const Point &r) const {       //向量加法
        return Point (x + r.x, y + r.y);
    }
    Point operator - (const Point &r) const {       //向量减法
        return Point (x - r.x, y - r.y);
    }
    Point operator * (double p)  {       //向量乘以标量
        return Point (x * p, y * p);
    }
    Point operator / (double p)  {       //向量除以标量
        return Point (x / p, y / p);
    }
    bool operator < (const Point &r) const {       //点的坐标排序
        return x < r.x || (x == r.x && y < r.y);
    }
    bool operator == (const Point &r) const {       //判断同一个点
        return dcmp (x - r.x) == 0 && dcmp (y - r.y) == 0;
    }
};
typedef Point Vector;       //向量的定义
Point read_point(void)   {      //点的读入
    double x, y;
    scanf ("%lf%lf", &x, &y);
    return Point (x, y);
}
double polar_angle(Vector A)  {     //向量极角
    return atan2 (A.y, A.x);
}
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 - A.y * B.x;
}
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 area_triangle(Point a, Point b, Point c) {       //三角形面积,叉积
    return fabs (cross (b - a, c - a)) / 2.0;
}
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 nomal(Vector A)  {       //向量的单位法向量
    double len = length (A);
    return Vector (-A.y / len, A.x / len);
}
Point point_inter(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 dis_to_line(Point p, Point a, Point b)   {       //点到直线的距离,两点式
    Vector V1 = b - a, V2 = p - a;
    return fabs (cross (V1, V2)) / length (V1);
}
double dis_to_seg(Point p, Point a, Point b)    {       //点到线段的距离,两点式

    if (a == b) return length (p - a);
    Vector V1 = b - a, V2 = p - a, V3 = p - b;
    if (dcmp (dot (V1, V2)) < 0)    return length (V2);
    else if (dcmp (dot (V1, V3)) > 0)   return length (V3);
    else    return fabs (cross (V1, V2)) / length (V1);
}
Point point_proj(Point p, Point a, Point b)   {     //点在直线上的投影,两点式
    Vector V = b - a;
    return a + V * (dot (V, p - a) / dot (V, V));
}
bool inter(Point a1, Point a2, Point b1, Point b2)  {       //判断线段相交,两点式
    double c1 = cross (a2 - a1, b1 - a1), c2 = cross (a2 - a1, b2 - a1),
           c3 = cross (b2 - b1, a1 - b1), c4 = cross (b2 - b1, a2 - b1);
    return dcmp (c1) * dcmp (c2) < 0 && dcmp (c3) * dcmp (c4) < 0;
}
bool on_seg(Point p, Point a1, Point a2)    {       //判断点在线段上,两点式
    return dcmp (cross (a1 - p, a2 - p)) == 0 && dcmp (dot (a1 - p, a2 - p)) < 0;
}
double area_poly(Point *p, int n)   {       //多边形面积
    double ret = 0;
    for (int i=1; i<n-1; ++i)   {
        ret += fabs (cross (p[i] - p[0], p[i+1] - p[0]));
    }
    return ret / 2;
}
/*
    点集凸包,输入点集会被修改
*/
vector<Point> convex_hull(vector<Point> &P) {
    sort (P.begin (), P.end ());
    P.erase (unique (P.begin (), P.end ()), P.end ());      //预处理,删除重复点
    int n = P.size (), m = 0;
    vector<Point> ret (n + 1);
    for (int i=0; i<n; ++i) {
        while (m > 1 && cross (ret[m-1]-ret[m-2], P[i]-ret[m-2]) < 0)   m--;
        ret[m++] = P[i];
    }
    int k = m;
    for (int i=n-2; i>=0; --i)  {
        while (m > k && cross (ret[m-1]-ret[m-2], P[i]-ret[m-2]) < 0)   m--;
        ret[m++] = P[i];
    }
    if (n > 1)  m--;
    ret.resize (m);
    return ret;
}

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

struct Line {
    Point p;
    Vector v;
    double r;
    Line () {}
    Line (const Point &p, const Vector &v) : p (p), v (v) {
        r = polar_angle (v);
    }
    Point point(double a)   {
        return p + v * a;
    }
};

/*
    直线相交求交点,返回交点个数,交点保存在P中
*/
int line_cir_inter(Line L, Circle C, double &t1, double &t2, vector<Point> &P)    {
    double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
    double e = a * a + c * c, f = 2 * (a * b + c * d), 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); P.push_back (L.point (t1));
        return -1;
    }
    t1 = (-f - sqrt (delta)) / (2 * e); P.push_back (L.point (t1));
    t2 = (-f + sqrt (delta)) / (2 * e); P.push_back (L.point (t2));
    if (dcmp (t1) < 0 || dcmp (t2) < 0) return 0;
    return 2;
}

/*
    两圆相交求交点,返回交点个数。交点保存在P中
*/
int cir_cir_inter(Circle C1, Circle C2, vector<Point> &P)    {
    double d = length (C1.c - C2.c);
    if (dcmp (d) == 0)  {
        if (dcmp (C1.r - C2.r) == 0)    return -1;      //两圆重叠
        else    return 0;
    }
    if (dcmp (C1.r + C2.r - d) < 0) return 0;
    if (dcmp (fabs (C1.r - C2.r) - d) < 0)  return 0;
    double a = polar_angle (C2.c - C1.c);
    double da = acos ((C1.r * C1.r + d * d - C2.r * C2.r) / (2 * C1.r * d));        //C1C2到C1P1的角?
    Point p1 = C1.point (a - da), p2 = C2.point (a + da);
    P.push_back (p1);
    if (p1 == p2)   return 1;
    else    P.push_back (p2);
    return 2;
}

int main(void)    {
    Circle C1, C2;  Point a, b;
    double Rm, R, r, x, y, vx, vy;
    while (scanf ("%lf%lf%lf%lf%lf%lf%lf", &Rm, &R, &r, &x, &y, &vx, &vy) == 7)    {
        Rm += r;    R += r;
        C1 = Circle (Point (0, 0), Rm);
        C2 = Circle (Point (0, 0), R);
        a = Point (x, y);   b = Point (vx, vy);
        vector<Point> P1, P2;   P1.clear ();    P2.clear ();
        double t1, t2, t3, t4, ans, speed = sqrt (vx * vx + vy * vy);
        int num1 = line_cir_inter (Line (a, b), C1, t1, t2, P1);
        int num2 = line_cir_inter (Line (a, b), C2, t3, t4, P2);
        if (num2 == 2)  {
            if (num1 == 2)   {
                double len = length (P2[0] - P2[1]) - length (P1[0] - P1[1]);
                ans = len / speed;
            }
            else    {
                ans = length (P2[0] - P2[1]) / speed;
            }
        }
        else    {
            ans = 0.0;
        }
        printf ("%.4f\n", ans);
    }

    return 0;
}

  

时间: 2024-12-07 12:24:25

简单几何(直线与圆的交点) ZOJ Collision 3728的相关文章

如何用几何画板构造直线与圆的交点

在学习数学几何时,经常会遇到圆与直线的关系问题.今天小编就来教大家如何用几何画板构造直线与圆的交点,从而能直观的表现出圆与直线的关系. 具体的操作步骤如下: 1.打开几何画板软件,执行“绘图”—“绘制新函数”命令,在弹出的对话框中依次单击“2”.“x”,做出函数解析式f(x)=2x,如下图所示,单击“确定”按钮,做出函数图像. 2.利用“圆工具”绘制一个圆,同时选中圆和直线,执行“构造”—“交点”命令,构造直线和圆的交点. 3.单击“文本工具”,将交点的标签设为A.B,如下图所示.拖动圆改变位置

简单几何(直线与线段相交) POJ 1039 Pipe

题目传送门 题意:一根管道,有光源从入口发射,问光源最远到达的地方. 分析:黑书上的例题,解法是枚举任意的一个上顶点和一个下顶点(优化后),组成直线,如果直线与所有竖直线段有交点,则表示能穿过管道. /************************************************ * Author :Running_Time * Created Time :2015/10/31 星期六 10:28:12 * File Name :POJ_1039.cpp ***********

简单几何(直线位置) POJ 1269 Intersecting Lines

题目传送门 题意:判断两条直线的位置关系,共线或平行或相交 分析:先判断平行还是共线,最后就是相交.平行用叉积判断向量,共线的话也用叉积判断点,相交求交点 /************************************************ * Author :Running_Time * Created Time :2015/10/24 星期六 09:08:55 * File Name :POJ_1269.cpp *********************************

第十二周项目4-3:点,圆的关系-输出线和圆的交点

问题及代码: /* *Copyright (c)2015,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称:project.cpp *作 者:陈文青 *完成日期:2015年5月31日 *版 本 号:v1.0 * *问题描述: (6)与圆心相连的直线:给定一点p,其与圆心相连成的直线,会和圆有两个交点,如图.在上面定义的Point(点)类和Circle(圆)类基础上, 设计一种方案,输出这两点的坐标. *程序输入: *程序输出: */ #include <ios

HDU 5572--An Easy Physics Problem(射线和圆的交点)

An Easy Physics Problem Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 3845    Accepted Submission(s): 768 Problem Description On an infinite smooth table, there's a big round fixed cylinder an

Gym - 101617F :Move Away (圆的交点)

pro:给定N个圆,求离原点最远的点,满足它在N个圆里.输出这个距离.N<50; sol:关键点一定是圆与圆的交点. 圆与 圆心到原点的直线 的交点. 然后去验证这些关键点是否在N个圆内. 实际操作的时候需要考虑一些条件: 1,求圆的交点的时候,先判断是否内含或者相离. 2,求直线与圆的交点的时候,先判断是否圆心就在原点处. 3,有可能不存在相交的圆. 如何求圆与圆的交点: 用atan2求出t,余弦定理求出a,即可. #include<bits/stdc++.h> #define rep

Python下opencv使用笔记(十一)(详解hough变换检测直线与圆)

在数字图像中,往往存在着一些特殊形状的几何图形,像检测马路边一条直线,检测人眼的圆形等等,有时我们需要把这些特定图形检测出来,hough变换就是这样一种检测的工具. Hough变换的原理是将特定图形上的点变换到一组参数空间上,根据参数空间点的累计结果找到一个极大值对应的解,那么这个解就对应着要寻找的几何形状的参数(比如说直线,那么就会得到直线的斜率k与常熟b,圆就会得到圆心与半径等等). 关于hough变换,核心以及难点就是关于就是有原始空间到参数空间的变换上.以直线检测为例,假设有一条直线L,

Python下opencv使用笔记(二)(简单几何图像绘制)

简单几何图像一般包括点.直线.矩阵.圆.椭圆.多边形等等.首先认识一下opencv对像素点的定义.图像的一个像素点有1或者3个值,对灰度图像有一个灰度值,对彩色图像有3个值组成一个像素值,他们表现出不同的颜色. 那么有了点才能组成各种多边形. (一)首先绘制直线 函数为:cv2.line(img,Point pt1,Point pt2,color,thickness=1,line_type=8 shift=0) 有值的代表有默认值,不用给也行.可以看到这个函数主要接受参数为两个点的坐标,线的颜色

几何画板验证圆幂定理流程

几何画板不仅可以方便地制作出各种几何图形,而且可以对几何定理进行实质性的验证.圆幂定理是平面几何中的一个定理,是相交弦定理.切割线定理及割线定理(切割线定理推论)的统一.下面将详细介绍几何画板验证圆幂定理课件的制作方法. 圆幂定理:如果交点为P的两条相交直线与圆O相交于A.B与C.D,则PA·PB=PC·PD. 几何画板制作的验证圆幂定理课件模板样图: 从上图中我们可以看出,交点为P的两条与圆O相交的直线AB.CD,在两条直线上分别取点E.F,通过演示可以发现分别拖动点E和点F,AP·BP=CP