C++博客-From A Start,As An Acmer-随笔分类-计算几何

HDU 4087 & BOJ 244 A Letter to Programmers 【三维仿射变幻的齐次矩阵乘+快速幂】

BUPT-[aswmtjdsj] @ Penalty — Mon, 07 Nov 2011 11:55:00 GMT

题意很裸，亮点在于将齐次仿射变换矩阵和快速幂结合起来。

题目读入延续了pku出题的ws风格，还得用一个dfs处理读入。
题目输出也很蛋疼，标准写法竟然会导致-0.0出现，必须手动加一个eps来修改偏差。没有spj的二货。

附上仿射变换矩阵：

平移

translate tx ty tz

1 0 0 tx

0 1 0 ty

0 0 1 tz

0 0 0 1

缩放

scale kx ky kz

kx 0 0 0

0 ky 0 0

0 0 kz 0

0 0 0 1

绕任意轴（过原点）旋转（注意要把轴向量归一化，不然会在“点在轴上”这个情况下出问题）

rotate x y z d

(1-cos(d))*x*x+cos(d) (1-cos(d))*x*y-sin(d)*z (1-cos(d))*x*z+sin(d)*y 0

(1-cos(d))*y*x+sin(d)*z (1-cos(d))*y*y+cos(d) (1-cos(d))*y*z-sin(d)*x 0

(1-cos(d))*z*x-sin(d)*y (1-cos(d))*z*y+sin(d)*x (1-cos(d))*z*z+cos(d) 0

0 0 0 1

附代码，一开始装b用stack模拟读入过程，re啊wa啊各种sb。最后被迫用了dfs。唉，naive。

#include
#include
#include
#include
#include
#include
using namespace std;
const double eps = 1e-6;
const double pi = acos(-1.0);
const int maxn = 1005;
int sgn(double x){return x < -eps?-1:x > eps;}
#define rep(i,j,k) for(int (i) = (j);(i) < (k);(i) ++)
struct matrix
{
    int r,c;
    double v[5][5];
    matrix(){}
    matrix(int a,int b):r(a),c(b)
    {
        rep(i,0,r)
            fill(v[i],v[i] + c,0.0);
        if(r == c)
        {
            rep(i,0,r)
                v[i][i] = 1.0;
        }
    }
    matrix init()
    {
        return matrix(r,c);
    }
    matrix operator * (const matrix p)
    {
        matrix ans(r,p.c);
        rep(i,0,r)
            rep(j,0,ans.c)
            {
                double tmp = 0.0;
                rep(k,0,c)
                    tmp += v[i][k] * p.v[k][j];
                ans.v[i][j] = tmp;
            }
        return ans;
    }
};
matrix power(matrix a,int n)
{
    matrix e(a.c,a.c);//square matrix of a.c * a.c
    if(n == 0)
        return e;
    matrix ans = power(a,n/2);
    ans = ans * ans;
    return (n%2)?ans * a : ans;
}
struct point
{
    double x,y,z;
    point(){}
    point(double a,double b,double c):x(a),y(b),z(c){}
    void in()
    {
        scanf("%lf %lf %lf",&x,&y,&z);
    }
    void print()
    {
        printf("%.2lf %.2lf %.2lf\n",x + eps,y + eps,z + eps);
    }
}p[maxn];
int n;
point fuck(point now,matrix a)
{
    matrix o(4,1);
    o.v[0][0] = now.x;
    o.v[1][0] = now.y;
    o.v[2][0] = now.z;
    o.v[3][0] = 1.0;
    matrix ans = a * o;
    return point(ans.v[0][0],ans.v[1][0],ans.v[2][0]);
}
char op[20];
matrix dfs(int times)
{
    matrix ans(4,4);
    double v[5];
    int what;
    while(scanf("%s",op) == 1)
    {
        matrix temp(4,4);
        if(op[0] == 'e')
            break;
        else if(op[0] == 'r')
        {
            if(op[1] == 'e')
            {
                scanf("%d",&what);
                temp = dfs(what);
            }
            else
            {
                rep(i,0,4)
                    scanf("%lf",&v[i]);
                double l = 0.0;
                rep(i,0,3)
                    l += v[i] * v[i];
                l = sqrt(l);
                v[3] = v[3] / 180.0 * pi;
                double ct = cos(v[3]),st = sin(v[3]);
                rep(i,0,3)
                    v[i] /= l;
                temp.v[0][0] = (1.0 - ct) * v[0] * v[0] + ct;
                temp.v[0][1] = (1.0 - ct) * v[0] * v[1] - st * v[2];
                temp.v[0][2] = (1.0 - ct) * v[0] * v[2] + st * v[1];
                temp.v[1][0] = (1.0 - ct) * v[1] * v[0] + st * v[2];
                temp.v[1][1] = (1.0 - ct) * v[1] * v[1] + ct;
                temp.v[1][2] = (1.0 - ct) * v[1] * v[2] - st * v[0];
                temp.v[2][0] = (1.0 - ct) * v[2] * v[0] - st * v[1];
                temp.v[2][1] = (1.0 - ct) * v[2] * v[1] + st * v[0];
                temp.v[2][2] = (1.0 - ct) * v[2] * v[2] + ct;
            }
        }
        else if(op[0] == 't')
        {
            rep(i,0,3)
            {
                scanf("%lf",&v[i]);
                temp.v[i][3] = v[i];
            }
        }
        else if(op[0] == 's')
        {
            rep(i,0,3)
            {
                scanf("%lf",&v[i]);
                temp.v[i][i] = v[i];
            }
        }
        ans = temp * ans;
    }
    return power(ans,times);
}
int main()
{
    while(scanf("%d",&n) == 1 && n)
    {
        matrix temp(4,4);
        temp = dfs(1) * temp;
        for(int i = 0;i < n;i++)
        {
            p[i].in();
            p[i] = fuck(p[i],temp);
            p[i].print();
        }
        puts("");
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-11-07 19:55 发表评论

HDU 2297 Run 【半平面交 or 维护单调性】

BUPT-[aswmtjdsj] @ Penalty — Sat, 05 Nov 2011 13:32:00 GMT

题目大意：
给n个人参加赛跑，给出某一时刻每个人的位置和速度（保证单向，速度恒定，且互不相同，且不为0），问，假如无限跑下去，过程中有可能有多少个不同的人领先过？（如果某一时刻两人同时领先，则都不算）

做法：
画成s-t图的话，很容易得出半平面交的做法，即以y轴和无穷远向这n条射线包围，求得围成的多边形内核上有多少条线段的问题（去掉y轴和无穷远）。
半平面交N^logN的我不会写，于是就用了himdd大神的模板，算法来源zzy大神的论文。
由于最后求得的点集可能有重点问题，需要先sort再unique一下去重。（表示这份代码用到了complex类，unique，distance等stl。。。太orz了）
代码：

#include
#include
#include
#include
#include
#include
using namespace std;
const double inf=1e-10;
const int Max=60010;
typedef complex<double> Point;
inline int dbcmp(double tp){return tp<-inf?-1:tp>inf;}
double operator^(Point a,Point b)
{return imag(conj(a)*b);}
struct Line{
    Point a,b;
    double angle;
    Line(){}
    Line(Point a,Point b):a(a),b(b){angle=arg(a-b);}
};
bool operator<(Line p,Line l){
    return dbcmp(p.angle-l.angle)<0||
        (dbcmp(p.angle-l.angle)==0&&dbcmp(p.b-p.a^l.b-p.a)<0);
}

Point operator*(const Line& u,const Line&v)
{
    Point tp=u.a;
    double fz=u.a-v.a^v.b-v.a;
    double fm=u.a-u.b^v.b-v.a;
    return tp+(u.b-u.a)*fz/fm;
}
bool onleft(Point p,Line u)
{
    return dbcmp(p-u.a^u.b-u.a)<=0;
}
bool uniquecmp(Line u,Line v)
{
    int a = dbcmp(u.angle-v.angle)==0;
    if(a)
        puts("cao");
    return a;
}
bool iter(Point p,Point q)
{
    return dbcmp(real(p) - real(q)) < 0 || (dbcmp(real(p) - real(q)) == 0 && dbcmp(imag(p) - imag(q)) < 0);
}
Point p[Max];
Line l[Max];
int e[Max];//line的下标
int get_kernel(Line *l,int lsz,Point *p )
{
    int eb=0,ee=2,pb=0,pe=1;
    sort(l,l+lsz);
    p[lsz]=p[0];
    lsz=distance(l,unique(l,l+lsz,uniquecmp));
    e[0]=0;e[1]=1;
    p[0]=l[0]*l[1];
    for(int i=2;i        while(pb!=pe&&!onleft(p[pe-1],l[i]))pe--,ee--;
        while(pb!=pe&&!onleft(p[pb],l[i]))pb++,eb++;
        p[pe++]=l[i]*l[e[ee-1]];
        e[ee++]=i;
    }
    while(pb!=pe&&!onleft(p[pe-1],l[e[eb]]))pe--,ee--;
    //这个循环好像是没有用的。。
    while(pb!=pe&&!onleft(p[pb],l[e[ee-1]]))pb++,eb++;
    p[pe++]=l[e[pb]]*l[e[ee-1]];
    int psz=pe-pb;
    for(int i=0;pb!=pe;i++)p[i]=p[pb++];
    return psz;//点的个数
}
bool uniqueccc(Point p,Point q)
{
    return  dbcmp(real(p)-real(q)) == 0 && dbcmp(imag(p)-imag(q))==0;
}
void gao()
{
    int n;int lsz=0;
    scanf("%d",&n);
    double x,y;
    for(int i=0;i    {
        scanf("%lf%lf",&x,&y);
        l[lsz++]=Line(Point(0,x),Point(1,x+y));
    }
    l[lsz++]=Line(Point(0,0),Point(1,0));
    l[lsz++]=Line(Point(1e22,0),Point(1e22,1));
    l[lsz++]=Line(Point(1,1e22),Point(0,1e22));
    l[lsz++]=Line(Point(0,1e22),Point(0,0));
    int psz=get_kernel(l,lsz,p);
    sort(p,p + psz,iter);
    psz = distance(p,unique(p,p + psz,uniqueccc));
    printf("%d\n",psz-2);
}
int main()
{
    int t;
    scanf("%d",&t);
    for(int i = 0;i < t;i++)
        gao();
}

另一个做法：
学自各种大牛的单调栈。
对于所有元素按照p进行从大到小的排序。因为初始时刻p最大的一定是解集元素之一，
所以虚拟一个元素（p与p最大值相同，速度为0），把这个虚拟元素和第一元素压入栈中，作为初始化。
然后对于之后的第i个元素，先判断它是否比所有已出现过的元素v都大，如果不大于，则直接跳过（因为p小，v同，肯定追不上），再之后就比较该元素追上栈顶下一个元素和栈顶元素追上栈顶下一个元素的时间，如果该元素时间短，就弹栈，直到出现>=为止，把该元素入栈。
最后栈中元素减一即为答案。
算法的原理在于，第一个元素肯定可以领先，然后就比较谁能更早的超过曾经领先过的元素，谁也就曾经“真的”领先过。
栈中元素保证了p单调非增，v单调增。维护出来的依旧是一个凸集，和半平面交效果相同。

有一个问题，很值得思考，这个做法对于所有约束条件符号完全相同的线性规划问题，是有通解性的吧？ax + by + c < 0，保证a，b，< 分别同号的情况下。
“维护单调性”。orz这个神想法。
附代码：

#include
#include
#include
#include
using namespace std;
#include
#define maxn 50005
typedef long long ll;
int t,n;
struct node
{
    int p,v;
    node(){}
    node(int _p,int _v):p(_p),v(_v){}
}nn[maxn];
int ss[maxn];
bool operator < (node a,node b){return a.p > b.p || (a.p == b.p && a.v < b.v);}
bool ok(node a,node b,node c)
{
    return (ll) (b.p - c.p) * (ll) (a.v - b.v) <= (ll)(b.p - a.p) * (ll)(c.v-b.v);
}
void gao()
{
    scanf("%d",&n);
    int a,b;
    for(int i = 0;i < n;i++)
    {
        scanf("%d %d",&a,&b);
        nn[i] = node(a,b);
    }
    sort(nn,nn + n);
    int top = 1;
    nn[n] = node(nn[0].p,0);
    ss[0] = n;
    ss[1] = 0;
    int fuck = nn[0].v;
    for(int i = 1;i < n;i++)
    {
        if(nn[i].v < fuck)
            continue;
        fuck = nn[i].v;
        while(top > 0 && ok(nn[ss[top]],nn[ss[top-1]],nn[i]))
            top--;
        ss[++top]=i;
    }
    printf("%d\n",top);
}
int main()
{
    scanf("%d",&t);
    for(int i = 0;i < t;i++)
        gao();
}

BUPT-[aswmtjdsj] @ Penalty 2011-11-05 21:32 发表评论

UVA 12303 Composite Transformations ［三维仿射矩阵］［更正：旋转轴归一化和平面三点式问题］

BUPT-[aswmtjdsj] @ Penalty — Thu, 03 Nov 2011 17:40:00 GMT

摘要: 三维仿射变换什么的，纠结了很多天想把绕任意轴旋转的齐次矩阵手推出来，最后，结果连sample都过不了，只能等回头再调了，目前先用着模板。所谓仿射变换，咱们通俗的讲就是通过补维把坐标转化为齐次矩阵的形式进行矩阵乘法，这样就能找到平移、拉伸、旋转的通式解。此处要用到的有三个变换矩阵：平移：(偏移量(dx,dy,dz))1 0 0 dx0 1 0 dy0 0 1 dz0 0 0 1放缩：(比例系数(sx... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-11-04 01:40 发表评论

UVA 12304 2D Geometry 110 in 1! 【几何基础知识题】【敲个两三百行也没啥是吧？咱们都是纯爷们儿】

BUPT-[aswmtjdsj] @ Penalty — Mon, 17 Oct 2011 04:15:00 GMT

摘要: 这题是RujiaLiu的几何专场中，第四简单的题目了。果断无脑流，果断需要敲无数行模板，果断需要考虑各种情况。还好srgba给的sample照顾到了所有情况，并且没有太卡精度，不过没有spj，不得不说老uva在这一点上太二了。题目六部分，六个和圆有关的问题。以及附上我的模板：预备知识（模板）：epssgn符号函数点（向量）类：构造、加、减、数乘（放缩）、点积、叉积、比较器、反向、法向、单位向量、向... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-10-17 12:15 发表评论

RuJia Liu's Contest 4 For CG lovers［全是几何有木有！］［A-E done!!］［5/15］

BUPT-[aswmtjdsj] @ Penalty — Sat, 01 Oct 2011 15:53:00 GMT

srgba哥越来越重口了。
自从数据结构专场之后又出了一套几何专场。。我了个去。
目前本菜ac的只有前三题。。

A	Smallest Regular Polygon

推个公式，本质就是拆分成n个小三角形的面积，n为偶时显然；n为奇时，长边对中心的角为(2pi/n)*floor(n/2)，易得中心到顶点的距离。

B	An Angular Puzzle

就是初中时候的平面几何。可惜纯手推推不出公式来，无奈用了正弦＋余弦定理。无解是指内角和不为180，多解是骗人的。

C	Nine-Point Circle

三点确定一个圆是大水题。

D	Composite Transformations

~~三维的仿射变换，还没写，好麻烦的。~~
终于搞定了。时隔一个月。

http://www.cppblog.com/aswmtjdsj/archive/2011/11/04/159593.html

E	2D Geometry 110 in 1!

http://www.cppblog.com/aswmtjdsj/archive/2011/10/17/158526.html
花了十天终于写完了。。。这。。。

F	Polishing a Extruded Polygon

金属铸造属于线性规划问题。－－某《计算几何》书言

G	My SketchUp

- -sketchup是个好软件啊。自己写就蛋疼了- -这尼玛模拟也太难了吧。

H	Smallest Enclosing Rectangle

最小面积／周长包围矩形是旋转卡壳。

I	Smallest Enclosing Box

最小包围长方体？？？这是神马？！（三维旋转卡壳？？？）

J	A Strange Opera House II

光线反射，又一个坑爹题。（邓老师的书上有伪代码的样子。。）

K	Point Location

平面点定位，邓老师的书：梯形剖分。

L	All-Pair Farthest Points

卡了好久，旋转卡壳处理共线点的时候会有各种bug，尤其这题还给了一个凸包。。。正解到底是神马？voronoi图？（据说三分可过）

M	Bounding Volume Hierarchy

这题太nb了。。。。。空间子区域划分。。。。。八叉树神马？！？

N	A Tiny Raytracer

lrj坑爹题。。。

O	The Cleaning Robot

机器人运动路径规划。。。脑中瞬间浮现了四个字“随意所之”。

感觉乳鸽就是把那本计算几何书上的算法出了一遍。。全身心坑爹。。。

BUPT-[aswmtjdsj] @ Penalty 2011-10-01 23:53 发表评论

BOJ 1790 Blow up the bridge 【弧扫描】

BUPT-[aswmtjdsj] @ Penalty — Sat, 24 Sep 2011 12:46:00 GMT

链接：http://o.boj.me/onlinejudge/showproblem.php?problem_id=1790
这是我们那年（10年）校赛网络预赛的一道不是很难的题。可是事后我做了一个星期也还是WAWATLETLE。。。
现在想来当年还是太naive了，用了一些乱七八糟甚至不是算法的算法外加了一大堆补丁妄图水过此题。但是事实证明歪门邪道不会带来AC。
经历了那么多以后，虽然我还是蒟蒻，但是好歹掌握了多一点的东西了，于是这题隐约可捉了。

题目大意：
一条线段，N个圆，问这条线段上没被圆覆盖的部分的长度是多少。

做法：
弧扫描。
求出这N个圆与线段所在直线的两个交点（如果有），定一个序，低优先级的为入点，标0，高的为出点，标1；把线段的两个端点标为其他标记，比如2。然后将这最多2*N+2个点排序，按序扫描一遍。
当遇到第一次2且没有遇到第二次2的时候进行统计，初始化in=0，out=0，遇0，in++；遇1，out++；当in==out的时候，加上该点到下一点的距离，而这个就是距离就是未被覆盖的长度的一部分。归纳可知，正确性显然。此即为弧扫描的最简单应用。类似思想出现在poj1981，定长半径圆覆盖最多点问题。
直线方程竟然解错了导致wa了一次，太二了。
x + b * y + c = 0 => b = -(x1-x2)/(y1-y2)!!!!!

犯了错误，我们才会思考；找到不足，我们才能进步。

#include <cstdio>

#include <iostream>

#include <cstring>
#include <cmath>
#include <algorithm>
#define sqr(x) ((x) * (x))
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
#define maxn 1005
int comp(double x)
{
    return fabs(x) < eps?0:x <-eps?-1:1;
}
struct point
{
    double x,y;
    point(){}
    point(double a,double b):x(a),y(b){}
    point operator -(point p)
    {
        return point(x - p.x,y - p.y);
    }
    double norm()
    {
        return sqrt(sqr(x) + sqr(y));
    }
};
struct circle
{
    point c;
    double r;
    circle(){}
    circle(point _c,double _r):c(_c),r(_r){}
}c[maxn];
struct line
{
    point p,q;
    double a,b,c;
    line(){}
    line(point _p,point _q):p(_p),q(_q)
    {
        if(comp(p.x - q.x) == 0)
        {
            a = 1.0;
            b = 0.0;
            c = -p.x;
        }
        else if(comp(p.y - q.y) == 0)
        {
            a = 0.0;
            b = 1.0;
            c = -p.y;
        }
        else
        {
            a = 1.0;
            b = -(p.x - q.x) / (p.y - q.y);
            c = -(b * p.y + p.x);
        }
    }
}L;
struct sol
{
    point p;
    int flag;
    sol(){}
    sol(point _p,int _f):p(_p),flag(_f){}
}s[maxn * 2];
bool operator <(const point a,const point b)
{
    return comp(a.x - b.x) < 0 || (comp(a.x - b.x) == 0 && comp(a.y - b.y) < 0);
}
bool operator <(const sol &a,const sol &b)
{
    return a.p < b.p;
}
int n;
void calc(circle o,point &p,point &q)
{
    double A,B,C,det;
    if(comp(L.a) == 0)
    {
        A = sqr(L.a) + sqr(L.b);
        B = 2.0 * L.a * (L.c + L.b * o.c.y) - 2.0 * sqr(L.b) * o.c.x;
        C = sqr(L.c + L.b * o.c.y) + sqr(L.b) * (sqr(o.c.x) - sqr(o.r));
        det = sqr(B) - 4.0 * A * C;
        if(comp(det) < 0)
            p = q = L.p;
        else
        {
            if(comp(det) == 0)
                det = 0.0;
            p.x = (-B + sqrt(det))/(2.0 * A);
            q.x = (-B - sqrt(det))/(2.0 * A);
            p.y = -(L.a * p.x + L.c) / L.b;
            q.y = -(L.a * q.x + L.c) / L.b;
            if(q < p)
                swap(p,q);
        }
    }
    else
    {
        A = sqr(L.a) + sqr(L.b);
        B = 2.0 * (L.b * L.c + L.a * L.b * o.c.x - sqr(L.a) * o.c.y);
        C = sqr(L.c + L.a * o.c.x) + sqr(L.a) * (sqr(o.c.y) - sqr(o.r));
        det = sqr(B) - 4.0 * A * C;
        if(comp(det) < 0)
            p = q = L.p;
        else
        {
            if(comp(det) == 0)
                det = 0.0;
            p.y = (-B + sqrt(det)) / (2.0 * A);
            q.y = (-B - sqrt(det)) / (2.0 * A);
            p.x = -(L.b * p.y + L.c) / L.a;
            q.x = -(L.b * q.y + L.c) / L.a;
            if(q < p)
                swap(p,q);
        }
    }
}
int main()
{
    while(scanf("%d",&n) == 1 && n)
    {
        for(int i = 0;i < n;i++)
        {
            double x,y,r;
            scanf("%lf %lf %lf",&x,&y,&r);
            c[i] = circle(point(x,y),r);
        }
        double x1,x2,y1,y2;
        scanf("%lf %lf",&x1,&y1);
        scanf("%lf %lf",&x2,&y2);
        L = line(point(x1,y1),point(x2,y2));
        int cnt = 0;
        s[cnt++] = sol(point(x1,y1),2);
        s[cnt++] = sol(point(x2,y2),2);
        for(int i = 0;i < n;i++)
        {
            point p,q;
            calc(c[i],p,q);
            s[cnt++] = sol(p,0);
            s[cnt++] = sol(q,1);
        }
        sort(s,s + cnt);
        int mark = 0,in = 0,out = 0;
        double ans = 0.0;
        for(int i = 0;i < cnt - 1;i++)
        {
            switch(s[i].flag)
            {
                case 0:
                    in++;
                    break;
                case 1:
                    out++;
                    break;
                case 2:
                    mark++;
                    break;
            }
            if(mark == 1 && in == out)
                ans += (s[i].p - s[i+1].p).norm();
        }
        printf("%.4lf\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-24 20:46 发表评论

HDU 4024 Dwarven Sniper’s hunting【水二分】

BUPT-[aswmtjdsj] @ Penalty — Sat, 10 Sep 2011 13:09:00 GMT

这。。。。。这题难道自带“错误题意引导”？？？为啥我就算读对了题意，想对了做法，结果敲的时候又按照错误的想法敲了呢？伤不起。。
其实04题才是本场最水题，但是- -题意太坑爹了。唉。

题意：
二维平面追击。
被追击的人有起始坐标，有一个速度矢量，从开始就一直在走。
追击者有起始坐标，有运动速率，射出的子弹也有一个速率。子弹有一个有效射击半径。
就问，在子弹飞行距离最远的情况下，让总追击时间（被追击者被击中前的运动时间）最短，最远距离是多少，最短时间是多少。（一直搞反了题意。妹的。）
条件保证，1e9的时间内一定有解，被追者速率<追者速率<子弹速率。
第二个条件保证了，时间短的时候打不中的话，将时间拉长就一定能打中。
做法：
由于一定有解，为了让飞行距离最长，那么就让它等于射击半径。
果断二分总时间。
得出被追者当前坐标，算出与追击者起始坐标的距离。以射击半径画圆，判断追击者是在圆内还是圆外。并算出小圆半径（即去除子弹时间的剩余时间乘以追击者的运动速率）。判断两圆状态，相离或相切则l = mid，相交则r=mid。（前者表示打不着还需要继续跑，后者表示打到了但不是最优所以要缩短）。
二分中间的某些状态大概可以表示追击者跑到某个地方停了下来，然后等被追击者跑到指定位置再开始秀枪法；但鉴于最优解一定不需要让追击者有等待时间，所以最后的最优状态一定是相切的。
话说因为不小心用到了除法，所以eps开到1e-6会被卡精度，所以没办法只能1e-8了。。第一次写的时候开到1e-6竟然连样例都有精度差，这。。。

唉，被题意坑啊，自己脑子笨，想不清楚二分啊，我弱爆了。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const double eps = 1e-6;
const double inf = 1e9;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
struct point
{
    double x,y;
    point(){}
    point(double a,double b):x(a),y(b){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y);
    }
    point operator *(const double a)
    {
        return point(x * a,y * a);
    }
    point operator +(const point p)
    {
        return point(x + p.x,y + p.y);
    }
    double norm()
    {
        return sqrt(x * x + y * y);
    }
}p1,p2,L;
double vd,vb,limit;
int main()
{
    while(scanf("%lf %lf %lf %lf %lf %lf %lf %lf %lf",&p1.x,&p1.y,&p2.x,&p2.y,&L.x,&L.y,&vd,&vb,&limit) == 9)
    {
        if(!comp(p1.x) && !comp(p1.y) && !comp(p2.x) && !comp(p2.y) && !comp(L.x) && !comp(L.y) && !comp(vd) && !comp(vb) && !comp(limit))
            break;
        double t2 = limit / vb;
        double l = 0.0,r = inf,mid;
        while(comp(l - r) < 0)
        {
            mid = (l + r) / 2.0;
            point now = p1 + L * mid;
            if(comp(t2 - mid) > 0)
            {
                l = mid;
                continue;
            }
            double d = (now - p2).norm();
            double most = (mid - t2) * vd;
            if(comp(d - limit) <= 0)
            {
                if(comp(d + most - limit) < 0)
                    l = mid;
                else
                    r = mid;
            }
            else
            {
                if(comp(most + limit - d) < 0)
                    l = mid;
                else
                    r = mid;
            }
        }
        printf("%.3lf %.3lf\n",limit,mid);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-10 21:09 发表评论

二维 & 三维费马点问题【没有理论研究，只有代码研究】

BUPT-[aswmtjdsj] @ Penalty — Fri, 09 Sep 2011 12:23:00 GMT

模拟退火什么的我只知道一个大概思想，然后会很矬的去实现它。近似算法真心伤不起啊唉。
例题：poj 2420 【二维多边形费马点】， uva 5102 【福州现场赛E题，四边形费马点，有结论，所以模拟退火应该不算正解】， ZOJ 2928 【三维费马点】。

模拟退火神马的就是一个迭代过程，在每次迭代中向所有可能的方向试探，然后选取其中最优的一个作为下一次的迭代起点；为了让迭代能够终止，设定了一个步长，每次迭代之后步长乘以一个小于1的系数来减小步长。
迭代方式是相同的，就是向所有可能的方向试探，再按规则模拟计算结果，比如二维点就是向8个方向试探之后再计算到所有点的距离和，而三维点就是26个方向了。
初始步长作为上界，这个该怎么设定我一直不太清楚，我反正是用最大可能步长作为上界的；初始迭代点，随手设置一个吧，我用的是所有点坐标的算术平均数，也可以用原点之类，但是我觉得无论选择啥点都不能保证绝对的正确性的吧（否则，“图灵奖”。。。）；迭代步长系数，好像我的写法比较矬？导致我必须把系数设到0.993以上才能过题，真是弱爆了；至于精度下界就设为1e-10就好了，反正不要钱，哈。

模拟退火的一大弊端在于，如果进入了某个次优解点的邻域，且此时步长已经很小的话，那很有可能就会陷入这个次优解邻域的漩涡里（俗话说叫掉坑里？好像有专业名词叫鞍点或者涡点什么的？我数学不太好不好意思。。），然后再也跑不出来。所以近似算法毕竟是“近似”算法，想避免掉入坑里，只能去优化写法或者找出答案的某种规律性，来分段或者剪枝迭代什么的。。我是玩不转这个了，如上所述的三题，我加起来交了五六十次了吧？总之是没有找到一组又能ac又快的好参数。唉。
我若爆了。。

附代码吧，以2928题为例：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define maxn 105
const double eps = 1e-12;
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
using namespace std;
struct point
{
    double x,y,z;
    point(double a = 0,double b = 0,double c = 0):x(a),y(b),z(c){}
    point operator - (const point p)
    {
        return point(x - p.x,y - p.y,z - p.z);
    }
    point operator + (const point p)
    {
        return point(x + p.x,y + p.y,z + p.z);
    }
    double norm()
    {
        return sqrt(x * x + y * y + z * z);
    }
    point operator *(double a)
    {
        return point(x * a,y * a,z * a);
    }
}p[maxn],fermat,dir[30];
int n;
int main()
{
    while(scanf("%d",&n) == 1)
    {
        for(int i = 0;i < n;i++)
            scanf("%lf %lf %lf",&p[i].x,&p[i].y,&p[i].z);
        int cnt = 0;
        for(int i=-1;i<=1;i++)
            for(int j=-1;j<=1;j++)
                for(int k = -1;k <= 1;k++)
                    dir[cnt++] = point(i,j,k);
        double step = 100;
        point now,ans;
        double temp = 1e10,calc;
        point sel;
        for(int i = 0;i < n;i++)
            ans = ans + p[i];
        ans = ans * (1.0 / (double)n);
        while(step > eps)
        {
            sel = ans;
            for(int i = 0;i < cnt;i++)
            {
                calc = 0.0;
                now = ans + dir[i] * step;
                for(int idx = 0;idx < n;idx++)
                    calc += (p[idx] - now).norm();
                if(comp(calc - temp) < 0)
                {
                    sel = now;
                    temp = calc;
                }
            }
            ans = sel;
            step *= 0.993;
        }
        printf("%.3f %.3f %.3f\n",ans.x,ans.y,ans.z);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-09 20:23 发表评论

UVA 5100 && FZU 2002 Shade of Hallelujah Mountain 【三维旋转、投影+凸包】

BUPT-[aswmtjdsj] @ Penalty — Wed, 07 Sep 2011 02:03:00 GMT

摘要: 好恶心的一题。给一个点，一个多面体，一个平面，假设点是光源，那么就问，多面体在平面上的投影面积为多少。做法：hint还是比较人道的，提示了旋转平面把三维凸包转成二维凸包的方法。（其实不能算是三维凸包，只不过是三维空间内的二维凸包；hint转化之后就变成了二维空间的二维凸包。）平面给的是平面方程Ax+By+Cz=D，那么平面法向量为(A,B,C)。目标是把平面旋转到和Z平面平行。根据hint的提示，... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-09-07 10:03 发表评论

HDU 4007 Dave 【双扫描线暴力】

BUPT-[aswmtjdsj] @ Penalty — Sun, 04 Sep 2011 04:04:00 GMT

比赛的时候用线段树做这题要么是不嫌麻烦就是贴标程了。。。那么水的题，1000的数据范围，果断N^2暴力啊。。
场上的时候claire大神瞬间1A，太犀利了。
维护四根双维度扫描线。
把读入的点copy一遍，一组x排序，一组y排序，用于两种扫描线的统计。
两根水平的，一左一右，保证距离不大于R；两根竖直的，用于统计，保证距离不大于R，且对于线框内的每个点判断是否在水平两根线的范围内，如果是则计数器加1，且当下扫描线上移时，如果是已经统计过的点则计数器减1。整体的思想类似队列。

附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 1005
struct point
{
    int x,y;
    point(){}
    point(int a,int b):x(a),y(b){}
}ver[maxn],par[maxn];
bool cmpx(point a,point b)
{
    return a.x < b.x;
}
bool cmpy(point a,point b)
{
    return a.y < b.y;
}
int n,R;
int main()
{
    while(scanf("%d %d",&n,&R) == 2)
    {
        for(int i = 0;i < n;i++)
        {
            int a,b;
            scanf("%d %d",&a,&b);
            ver[i] = point(a,b);
            par[i] = point(a,b);
        }
        sort(ver,ver + n,cmpy);
        sort(par,par + n,cmpx);
        int posl,posr,posu,posd;
        int l = 0,r = 0,u = 0,d = 0;
        int ans = 0;
        for(l = 0;l < n;l++)
        {
            posl = par[l].x;
            while(par[r].x - posl <= R && r < n)
                r++;
            posr = par[r - 1].x;
            u = 0;
            int temp = 0;
            for(d = 0;d < n;d++)
            {
                posd = ver[d].y;
                if(d != 0 && ver[d - 1].x <= posr && ver[d - 1].x >= posl)
                    temp--;
                for(;u < n;u++)
                {
                    if(ver[u].y - posd > R)
                        break;
                    if(ver[u].x >= posl && ver[u].x <= posr)
                        temp++;
                }
                ans = max(ans,temp);
                if(u == n - 1)
                    break;
            }
        }
        printf("%d\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-04 12:04 发表评论

FZU 1981 Three Kingdoms 【排序+二分】

BUPT-[aswmtjdsj] @ Penalty — Fri, 02 Sep 2011 12:06:00 GMT

2010福州网预的题目
M个点，向N个点发出射线，方向向量为同一向量。(M <= 10000,N <= 10000)坐标都是三维。
问这N个点中最多有多少个点被射中。

做法：排序+二分，O((M+N)logM)
因为方向向量的模恒不为0。那么就可以利用方向向量来投影。
将M个点投射到同一平面内（方向向量的三维，哪一维不为0，就投射到哪一维对应的品面），构造一个新的数据组，维护其他两维和放缩比例。然后将这个新数组排序。比较级为先p，后q，再val。
接下来，对N个点中的每个也按同样方式投射，二分查找在平面内的所在位置，判断所在位置是否与M个点中的某个点的投影重合，再判断放缩比例是否符合要求（放缩变量越大说明点越靠“后”），统计即可。
这题坑爹的卡STL，set、map均超时，用了lower_bound才过，而且竟然比我手写的二分还快。泪目。。卡了一年的题终于过了。
附代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define maxn 10005
using namespace std;
int t,n,m;
const double eps = 1e-8;
int comp(double x)
{
    return (fabs(x) < eps ? 0 : x < -eps ? -1: 1);
}
struct point
{
    double x,y,z;
    point(){}
    point(double a,double b,double c):x(a),y(b),z(c){}
    void read()
    {
        scanf("%lf %lf %lf",&x,&y,&z);
    }
}cro[maxn],ene[maxn],vec;
struct sol
{
    double x,y,val;
    sol(){}
    sol(double a,double b,double e):x(a),y(b),val(e){}
}s[maxn];
bool operator < (const sol a,const sol b)
{
    return comp(a.x - b.x) < 0 || (comp(a.x - b.x) == 0 && comp(a.y - b.y) < 0) || (comp(a.x - b.x) == 0 && comp(a.y - b.y) == 0 && comp(a.val - b.val) < 0);
}
void gao()
{
    scanf("%d %d",&n,&m);
    double x,y,z;
    for(int i = 1;i <= n;i++)
        ene[i].read();
    for(int i = 1;i <= m;i++)
        cro[i].read();
    vec.read();
    int mod = 0;
    if(comp(vec.x) != 0)
        mod = 1;
    else if(comp(vec.y) != 0)
        mod = 2;
    else if(comp(vec.z) != 0)
        mod = 3;
    for(int i = 1;i <= m;i++)
    {
        double temp;
        double p,q;
        switch(mod)
        {
            case 1:
                temp = (0.0 - cro[i].x) / vec.x;
                p = cro[i].y + temp * vec.y;
                q = cro[i].z + temp * vec.z;
                break;
            case 2:
                temp = (0.0 - cro[i].y) / vec.y;
                p = cro[i].x + temp * vec.x;
                q = cro[i].z + temp * vec.z;
                break;
            case 3:
                temp = (0.0 - cro[i].z) / vec.z;
                p = cro[i].x + temp * vec.x;
                q = cro[i].y + temp * vec.y;
                break;
        }
        s[i] = sol(p,q,temp);
    }
    sort(s + 1,s + m + 1);
    int ans = 0;
    for(int i = 1;i <= n;i++)
    {
        double temp,p,q;
        switch(mod)
        {
            case 1:
                temp = (0.0 - ene[i].x) / vec.x;
                p = ene[i].y + temp * vec.y;
                q = ene[i].z + temp * vec.z;
                break;
            case 2:
                temp = (0.0 - ene[i].y) / vec.y;
                p = ene[i].x + temp * vec.x;
                q = ene[i].z + temp * vec.z;
                break;
            case 3:
                temp = (0.0 - ene[i].z) / vec.z;
                p = ene[i].x + temp * vec.x;
                q = ene[i].y + temp * vec.y;
                break;
        }
        sol *low = lower_bound(s + 1,s + m + 1,sol(p,q,temp));
        for(sol * it = low;it != s + m + 1;it++)
        {
            if(comp(it -> x - p) != 0 || comp(it -> y - q) != 0)
                break;
            if(comp(it -> x - p) == 0 && comp(it -> y - q) == 0)
            {
                if(comp(it -> val - temp) >= 0)
                {
                    ans++;
                    break;
                }
            }
        }
    }
    printf("%d\n",ans);
}
int main()
{
    scanf("%d",&t);
    for(int i = 1;i <= t;i++)
    {
        printf("Case %d: ",i);
        gao();
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-09-02 20:06 发表评论

ZOJ 3521 Fairy Wars【并查集，扫描线，set维护】

BUPT-[aswmtjdsj] @ Penalty — Mon, 29 Aug 2011 12:45:00 GMT

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3521
以前一直以为扫描线这么神奇的想法应该有很复杂的代码，今天亲身写了一下，发现只要数据结构维护的好，代码真的很短。
感谢wolf5x大神、schnee大神对我这蒟蒻的指导。

题目大意：有一个圆形炸弹，给定二维坐标和半径；平面上N个点（N<=50000），每个点的二维坐标给出；给定一个L，是这些点的影响范围，影响范围是以这个点为中心的长度为L的正方形；影响范围内的点可以互相影响，连锁具有传递性。问，把炸弹引爆的话，会有多少个点被连锁。

做法：扫描线+set维护+并查集+枚举（最后一个随便说说。。。）

具体：裸的想法就是连边并查集，这个是O(N^2)的复杂度，铁挂；几何题的自然想法就是想到极角排序和扫描线以及线段树上面去。
极角排序没有好想法，线段树不会搞，就想扫描线+set维护的神想法。
一开始想环形扫描线想不出个所以然来，经大神们点拨后开始拿传统的坐标序扫描线搞之。

将这N个点按x坐标排序，维护两根扫描线或者说一个队列，一开始队列头尾都指向最左点，队列尾向右移动的时候先判断头尾两点的横坐标差值是否大于L，大于则把对头右移直到满足条件，同时将弹队的这些点在set中删除：

set中的元素是一个pair，first是点的纵坐标，second是点的id，这样就保证了内部没有重复元素，内部序按照y排序；然后将队尾的元素插入set中，因为插入函数的返回值是一个pair，pair的first即为队尾的点在set中的插入位置，second是插入成功与否的bool。

所以it-1(it != set.begin() )和it+1(it+1 != set.end() )分别是set中与当前插入点y坐标最相近的两个点，比较当前点与这两个的y坐标之差是否小于等于L，是则union之。可以归纳证明，需要判断的只有最近的两个点，因为更远的点已经在之前判断过了。

这样扫描一遍过后，就剩下几个联通块；再扫描一遍，判断圆是否与某个联通块相交，若相交则将联通块大小加到答案上，最后输出答案即可。

注意点：
1.为了防止浮点数误差，判断点在圆内的时候，直接用整数平方判断的，所以会超int，注意long long。
2.维护的时候注意尽量少写特判语句，比如初始点什么的，用一个统一化的判断语句来判断弹队与否，比如front 与 tail的距离什么的。。
3.set的insert函数的返回值的first是个指针，所以当我们插入的元素即为一个pair时，访问pair的first需要用->而非.
4.set的元素是一一对应的，无重复元素；用insert来实现find的功能，原因在于set没有单关键字查询功能，或者说没有我们想要的对于pair内某一元素的查询功能，所以用insert来实现find，是一个更巧妙的想法。
5.我是个蒟蒻，又tmd把并查集写错了。
6.思维比较神的题、各种算法联合在一起的题目不一定需要很大的代码量，不要被吓住。

附上代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <queue>
#include <algorithm>
#include <cstdlib>
#include <vector>
#define maxn 50005
using namespace std;
struct point
{
    long long x,y;
    point(){}
    point(long long _x,long long _y):x(_x),y(_y){}
    point operator -(const point p)
    {
        return point(x - p.x,y - p.y);
    }
    long long norm2()
    {
        return x * x + y * y;
    }
}p[maxn],c;
typedef set <pair<long long,int> > SET;
SET S;
SET::iterator it;
long long ab(long long x)
{
    return x >= 0?x : -x;
}
bool cmp(const point &a,const point &b)//for sort
{
    return a.x < b.x;
}
int n,l;
long long r;
int f[maxn],ra[maxn];
bool has[maxn];
int find(int x)
{
    return x == f[x] ? x : f[x] = find(f[x]);
}
void un(int a,int b)
{
    a = find(a);
    b = find(b);
    if(a != b)
    {
        if(ra[a] > ra[b])
        {
            f[b] = a;
            ra[a] += ra[b];
        }
        else
        {
            f[a] = b;
            ra[b] += ra[a];
        }
    }
}
void gao()
{
    S.clear();
    int front = 1;
    int a,b;
    for(int i = 1;i <= n;i++)
    {
        while(ab(p[i].x - p[front].x) > l)
        {
            S.erase(make_pair(p[front].y,front));
            front++;
        }
        it = S.insert(make_pair(p[i].y,i)).first;
        if(it != S.begin())
        {
            it--;
            if(ab(p[i].y - (it -> first)) <= l)
            {
                a = i;
                b = it -> second;
                un(a,b);
            }
            it++;
        }
        it++;
        if(it != S.end() && ab(p[i].y - (it -> first)) <= l)
        {
            a = i;
            b = it -> second;
            un(a,b);
        }
    }
}
int main()
{
    while(scanf("%d %lld %d",&n,&r,&l) == 3)
    {
        fill(ra,ra + n + 1,1);
        l /= 2;
        for(int i = 1;i <= n;i++)
            f[i] = i;
        for(int i = 1;i <= n;i++)
            scanf("%lld %lld",&p[i].x,&p[i].y);
        sort(p + 1,p + n + 1,cmp);
        scanf("%lld %lld",&c.x,&c.y);
        gao();
        int ans = 0;
        memset(has,0,sizeof(has));
        for(int i = 1;i <= n;i++)
        {
            if((p[i] - c).norm2() <= r * r)
            {
                int fuck = find(i);
                if(!has[fuck])
                {
                    ans += ra[fuck];
                    has[fuck] = true;
                }
            }
        }
        printf("%d\n",ans);
    }
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-29 20:45 发表评论

HDU 3961 Crisis【恶心的几何模拟】

BUPT-[aswmtjdsj] @ Penalty — Wed, 24 Aug 2011 13:26:00 GMT

摘要: 链接：http://acm.hdu.edu.cn/showproblem.php?pid=3961这题竟然有队伍场上过掉了。。大神们的脑子得有多清楚。。。我这题是做了一天才理清思路，过了样例。。这题的样例就已然强的一B了。。题目大意即做法，题意很裸，直接把做法说出来了，所以就是模拟题咯。先给你一个圆和圆外一点，然后给你一个多边形（不一定凸凹），将多边形绕圆心公转，同时自转，给你转动周期和时间。让你... 阅读全文

BUPT-[aswmtjdsj] @ Penalty 2011-08-24 21:26 发表评论

Ural 1588 Jamaica［平面图最短路？］

BUPT-[aswmtjdsj] @ Penalty — Sat, 20 Aug 2011 17:15:00 GMT

http://acm.timus.ru/problem.aspx?space=1&num=1588

题目一点也不不像所说的那么神。。。虽然标准的O(N^2 * logN)的算法不会吧。不过O(N^3)的算法还是能过的。

给你平面上N个点(<=300)。两两连边，求生成网络的路径总长，注意在同一直线上的边长不要重复计算。

O(N^2)预处理出每两点间最短路。然后利用类似floyd的想法N^3枚举出需要处理掉的边，即诸如d[i][j] = d[i][k] + d[k][j]的边，统计所有边长的时候不要加入此种d[i][j]的值。
关键点1：用double的坏处就在这了，自带常矬卡精度。随随便便就可以构造出那种三点构成的三角形最大内角近似180度的情况用来卡这种处理方式。
即三点近似共线的情况用于卡这个式子fabs(d[i][j] - d[i][k] - d[k][j]) < eps。。一开始eps=1e-6果断被卡了，处理到1e-9才在题目给出的数据范围(10^4)下可以不被精度所影响。
“精度”啊“精度”！！！
关键点2：平常不注意cout输出流的格式自适应，用的太习惯以致于察觉不到这种最常见的小事。这你妹。我真是个蒟蒻啊。
cout输出流对于大double数如果不iomanip的话是会自动用科学计数法输出的！！！平常用cout输出二分中间结果的时候经常会看到，现在怎么想不到了呢！！！我真是太弱了。。。
所以对于哪怕题目要求最后输出四舍五入后的整数，也不要“cout<
少年啊，要记住，非常习惯的事物的小小细节也许是你不曾注意到的坑你的地方。世界上的事情不要想当然。无论在什么方面。

BUPT-[aswmtjdsj] @ Penalty 2011-08-21 01:15 发表评论

我是蒟蒻！！！！别再在脑子里面出乱子了！！！【判断点在线段上的写法！】

BUPT-[aswmtjdsj] @ Penalty — Sat, 20 Aug 2011 02:27:00 GMT

bool check(point p,point a,point b)

{

if((comp(a.x - p.x) <= 0 && comp(p.x - b.x) <= 0) || (comp(a.x - p.x) >= 0 && comp(p.x - b.x) >= 0))

{

if((comp(b.y - p.y) >= 0 && comp(p.y - a.y) >= 0) || (comp(b.y - p.y) <= 0 && comp(p.y - a.y) <= 0))

return true;

}

return false;

}

别二了少年！！！洗洗睡吧！！！

BUPT-[aswmtjdsj] @ Penalty 2011-08-20 10:27 发表评论

URAL 1215 Exactness of Projectile Hit 【点到线段的距离和点在多边形内与否的判断】

BUPT-[aswmtjdsj] @ Penalty — Fri, 19 Aug 2011 13:30:00 GMT

题目链接：http://acm.timus.ru/problem.aspx?space=1&num=1215

坑爹的题，让我交了17次才过。。。。这。。
几个关键点。（判断点在“凸”多边形内，果断用叉积判断而非“角和”判断吧。我不知道ural怎么做到的，我把eps开到了1都能把我的“角和”判断卡掉，太nb了。）
1.叉积判断点在多边形内或上
如果旋转叉积过程中出现“正”以及“负”号情况发生，则点在“凸”多边形外。前提，点按顺/逆时针给出。
2.点到线段的距离
根据点积判断点与线段两端点组成的三角形的两个底角（相对于用于判断的点而言）是否均非钝角。
若有一个钝角，则点到线段的距离为点到两端点距离中的小者；若无，则为垂足距离。

（自己写的几何模板不要偷懒。。能用向量绝不解析。。。不然卡精度卡死你。。还有，有标准做法的，千万不要用偷懒做法水过去，不然以后会后悔的）
附代码：

#include <iostream>
#include <cstdio>
#include <cmath>
#define sqr(x) ((x) * (x))
using namespace std;
#define maxn 105
const double eps = 1e-6;
const double pi = acos(-1.0);
int comp(double x)
{
    if(fabs(x) < eps)
        return 0;
    else if(x < -eps)
        return -1;
    else
        return 1;
}
struct point
{
    int x,y;
    point(){}
    point(int a,int b):x(a),y(b){}
    point operator -(const point &p)
    {
        return point(x - p.x,y - p.y);
    }
    int operator *(const point &p)
    {
        return x * p.x + y * p.y;
    }
    int operator ^(const point &p)
    {
        return x * p.y - y * p.x;
    }
    int norm2()
    {
        return sqr(x) + sqr(y);
    }
}p[maxn],o;
int multi(point a,point b,point o)
{
    return (a - o) ^ (b - o);
}
int scalar(point a,point b,point o)
{
    return (a - o) * (b - o);
}
int n;
int main()
{
    int a,b;
    scanf("%d %d",&a,&b);
    o = point(a,b);
    scanf("%d",&n);
    for(int i = 0;i < n;i++)
    {
        scanf("%d %d",&a,&b);
        p[i] = point(a,b);
    }
    bool pos = false,neg = false;
    for(int i = 0;i < n;i++)
    {
        int a = i,b = (i + 1) % n;
        int flag = multi(p[a],p[b],o);
        if(flag > 0 && !pos)
            pos = true;
        if(flag < 0 && !neg)
            neg = true;
    }
    if(!(neg && pos))
    {
        printf("%.3lf\n",0.0);
        return 0;
    }
    double r = 1e10;
    for(int i = 0;i < n;i++)
    {
        int a = i,b = (i + 1) % n;
        double lab = sqrt((double)(p[a] - p[b]).norm2()),lbo = sqrt((double)(o - p[b]).norm2()),lao = sqrt((double)(o - p[a]).norm2());
        int sbao = scalar(p[b],o,p[a]),sabo = scalar(p[a],o,p[b]);
        double bao = acos((double) sbao / (lab * lao)),abo = acos((double)sabo / ( lab * lbo));
        if(comp(bao - pi / 2.0) <= 0 && comp(abo - pi / 2.0) <= 0)
            r = min(r,fabs((double)multi(p[a],p[b],o)) / lab);
        else
            r = min(r,min(lbo,lao));
    }
    printf("%.3lf\n",r * 2.0);
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-19 21:30 发表评论

Ural 1640 Circle of Winter【坑爹题。。。】

BUPT-[aswmtjdsj] @ Penalty — Sun, 14 Aug 2011 13:32:00 GMT

1640. Circle of Winter

Time Limit: 1.0 second
Memory Limit: 64 MB

Lich Sandro declared war to the King of Hell, and now hordes of demons are fighting fiercely against Sandro's army of the undead. Sandro has mastered the Magic of Fire, but the creatures of Hell can't be damaged by fire. That's why Sandro decided to use a “Circle of Winter” spell against them. This spell creates an indestructable circular-shaped ice wall. The demons who are touched by the circumference die immediately; the demons enclosed in a circle stay alive, but can't participate in the fight anymore.

Sandro can teleport to any point of the battlefield instantly and cast a “Circle of Winter” there. An ice wall centered in that point will appear in that case. Note that Sandro's magic skills allow him to cast a wall with a radius not exceeding 10000 metres. Now Sandro wants to choose a point to teleport to and a radius of a spell in such way that at least one demon would be killed and all the rest would be enclosed in a circle.

Input

The first line contains an integer n — the number of demons (1 ≤ n ≤ 100). Demons can be considered as points on the battlefield. The next n lines contain n pairs of space-separated integers (x, y) — the coordinates of the demons relative to the point Sandro occupies before teleportation. Coordinates are given in metres and don't exceed 1000 in absolute value. Each point of the battlefield contains no more than one demon; also a demon can't occupy a point the Sandro occupies before teleportation.

Output

Output 3 real numbers precise up to 10⁻⁹ — the coordinates of a point Sandro should teleport to and the radius of a “Circle of Winter” he should create. Sandro can't teleport to a point that is occupied by a demon. It is guaranteed that the solution always exists.

Samples

input	output
7 1 1 1 5 3 6 5 3 8 0 9 5 5 9	5 4 5
2 0 2 2 0	1 1 1.41421356237309

Problem Author: Dmitry Ivankov (prepared by Alexander Ipatov)
Problem Source: USU Junior Contest, October 2008

Tags: geometry

去年看到的时候就不会。今年会了最小覆盖圆的模板，试着做，结果依然WA，估计是找到的最小覆盖圆和给定的点中的某一个重复了。
仔细一想，试了试，竟然是坑爹题。
题目给你N个二维整点（坐标绝对值不大于1000），让你找一个点使这N个点中至少有一个在圆上，其他均在圆内，且圆半径小于10000，且圆心不与已知点重合。输出圆心坐标和半径（实数，精确到1e-9）

这题坑爹之处在于，不要求输出半径最小解。
那么即可随意构造解了。
只要任意实数解都可，因为题目给出的点都是整点。
这样你就令c.x = 0.1,c.y = 0.1，然后求出这个圆心到这N个点的最远距离，即为半径，然后AC。
我了个去。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
#define maxn 105
const double eps = 1e-9;
double x[maxn],y[maxn],cx,cy,r;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i = 0;i < n;i++)
        scanf("%lf %lf",&x[i],&y[i]);
    cx = cy = 0.1;
    r = 0.0;
    for(int i = 0;i < n;i++)
        r = max(r,sqrt((cx - x[i]) * (cx - x[i]) + (cy - y[i]) * (cy - y[i])));
    printf("%.10lf %.10lf %.10lf\n",cx,cy,r);
}

BUPT-[aswmtjdsj] @ Penalty 2011-08-14 21:32 发表评论

POJ 1981 Circle and Points 【定长圆覆盖最多点问题】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:14:00 GMT

定长圆覆盖最多点问题

问题描述，给出二维平面内N个点的(x,y)坐标，给一固定半径R。求一圆，圆心位置任意，要求尽可能多的覆盖平面点集中的点。输出最多的覆盖点数。

（限制条件，保证无任意两点距离等于2R，即无两点连线恰为直径。亦无任意三点同时在一个半径为R的圆上。）

朴素算法：由限制条件可知，最后目标圆圆心一定可由某两点唯一确定（即目标圆的圆弧上一定恰有两个平面点集中的点）。具体实现：C(N,2)枚举任意两圆，构造可行圆，枚举N个点，判断是否在圆上或者圆内（即是否被覆盖）。复杂度O(N^3)。

（如果过了就算是水过去的吧，没过就怪常数太大。。= =||）

我所知的标准做法：O(n^2*logn)的圆上交点扫描法。

转化为圆上的弧最多被覆盖几次的问题。

直觉可解，圆上某个弧如果被某个圆覆盖过，那么我们把目标圆圆心放在该段弧上时，目标圆一定能把该弧所在圆圆心覆盖（即平面点集中的某点）。

所以，被覆盖次数最多的弧的被覆盖次数即为目标圆（最优）最多能够覆盖的点数。

具体做法：

依旧是C(N,2)枚举任意两点，以BA为例，此时i=1,j=0。

求取BA的极角theta，利用atan2（因变量范围(-pi,pi]）。

为方便极角排序，对于负角要+2pi。

B、A构造的圆交于X1，X4两点，求取X1B与BA的夹角和X4B与AB的夹角（相同）。

Phi ，acos(D/2.0/R)，D=dis(A,B)。

以上可得出两圆交点在当前圆上对于圆心的极角。

为方便极角排序，每个极角均加2pi，使域扩张到[0，4pi]，从而防止了跨0角的出现。

alpha[t].value=theta – phi + 2pi,alpha[t].flag = 1(弧的进入端)

alpha[t+1].value = theta + phi + 2pi,alpha[t+1].flag = false（弧的退出端）。

接下来，对于每个圆上的t（偶数）个极角进行排序，再顺序扫描，动态更新最大值。

for(i,0,t)

if(alpha[i].flag)

sum++

else

sum--

if(sum > ans)

ans = sum

最后输出答案时，输出ans+1即可。（因为要算上弧所在圆自身）

复杂度：O(n *(nlogn + t))=O(n^2*logn)

题目链接：http://poj.org/problem?id=1981
http://boj.me/onlinejudge/showproblem.php?problem_id=1679

#include <iostream>

#include <cstdio>

#include <cmath>

#include <algorithm>

#define Mn 300//平面点集中点数

using namespace std;

const double eps = 1e-9;//精度调高点没跑~

const double pi = acos(-1.0);

#define sqr(x) ((x) * (x))

double R;//定长

struct point

{

    double x,y;

    void read()

    {

       scanf("%lf%lf",&x,&y);

    }

    void print()

    {

       printf("%lf%lf\n",x,y);

    }

    double friend dis(const point &a,const point &b)

    {

       return sqrt(sqr(a.x - b.x) + sqr(a.y - b.y));

    }

}p[Mn + 5];

struct alpha

{

    double v;

    bool flag;

    bool friend operator <(const alpha &a,const alpha &b)//排序专用偏序关系

    {

       return a.v < b.v;

    }

}alp[Mn * Mn + 5];//C(N,2)*2的可能交点（可能极角）

void solve(int n)

{

    R = 1.0;//本题内为单位圆

    for(int i = 0;i < n;i++)

       p[i].read();

    int MAX = 0;

    for(int i = 0;i < n;i++)

    {

       int t = 0;

       for(int j = 0;j < n;j++)

       {

           if(i == j)

              continue;

           double theta,phi,D;

           D = dis(p[i],p[j]);

           if(D > 2.0 * R)//距离超界直接秒杀

              continue;

//关键部分

           theta = atan2(p[j].y - p[i].y,p[j].x - p[i].x);

           if(theta < 0)

              theta += 2 * pi;

           phi = acos(D / (2.0 * R));

           alp[t].v = theta - phi + 2 * pi;

           alp[t].flag = true;

           alp[t + 1].v = theta + phi + 2 * pi;

           alp[t + 1].flag = false;

           t += 2;

       }

       sort(alp,alp + t);

       int sum = 0;

       for(int j = 0;j < t;j++)

       {

           if(alp[j].flag)

              sum ++;

           else

              sum --;

           if(sum > MAX)

              MAX = sum;

       }

    }

    printf("%d\n",MAX + 1);

}

int main()

{

    int n;

    while(scanf("%d",&n) == 1 && n)

    {

       solve(n);

    }

}

//欢迎围观，请大神轻拍~~~

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:14 发表评论

HDU 3471 England vs Germany 【三维线段判定】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 05:08:00 GMT

2010MU（ACM2010多校联合训练）-Fourth-UESTC-C Problem-England vs Germany-Solution Report

前言：这个2B题。谁出的谁自杀去。题目描述和数据还有官方解题报告都对着干。我们这帮做题的情何以堪！？

Description

The big fight between England and Germany was destroyed by the guy called Larrionda. England could have made a tie of 2:2. But that poor guy disqualified Lampard's wonderful goal. The ball passed through the goal line by half a meter, however, Larrionda turned a blind eye to this goal.

As a fan of Three Lion Regimen, silentsky want to develop a system which uses sensors to get the information to check if it scored or not.

The information includes a point as the location of ball, a vector as the velocity and a cuboid as the goal.

译文大意：

三狮军团和德意志战车单挑的时候，裁判拉里昂达2B了。因为拉里昂达的2B，那个完美进球被吹没了，本来有可能打平的比赛变成了日耳曼人屠戮了盎格鲁撒克逊人。

出题的人是个英粉，现在，他想让你编程构建一个系统来确定那个球到底是进还是没进。

所给信息包括，足球起始位置，速度矢量，以及，球门长方体八点。（均为三维坐标）

Input：

The first line gives an integer t (t<=10000) indicating the number of test cases.

For each case:

The first line gives three real numbers x, y , z, indicating a point to represent the ball.

The second line gives three real numbers a, b, c. indicates a vector to represent the velocity.

The following 8 lines give 8 points according the sequence A, B, C, D, E, F, G, H as is shown in the figure.

Absolute value of all real numbers are smaller than 10000.

It is guaranteed that the initial location of the ball is not inside the goal.

译文：

第一行为测试数据组数（小于等于10000的整数）。

第二行是球的坐标。

第三行是速度矢量。

第4~11行是按序给出的A~H八点的坐标。

（以上数据除组数外均为实数）

所有实数的绝对值均小于10000。

确保球的初始位置不在球门内。（这句话是让无数人WA的关键。实际的测试数据中给出了在球门内的数据。）（怎么说呢。是写解题报告和出题的人没有和写标程测试数据的人统一好意见呢。还是根本就没认真对待出题这种神圣的事情，纯粹2B了呢？！）

（自己建的图，特意下载了个AutoCAD2010.花了一个小时玩明白一点点建了个图）

Output：

if it scored then output “Case X: Stupid Larrionda!!!”.otherwise output “Case X: Intelligent Larrionda!!!”.(X is the case number starting from 1).

（We consider ABCD as the front of the goal and AB,BC,CD,DA as the goalposts. A shoot scores if and only if it passes through the front of the goal and doesn't crash on the goalpost)

译文：如果球进了，我们就输出“Case X: Stupid Larrionda!!!”（第X种情况：愚蠢的拉里昂达！！！）否则就输出 “Case X: Intelligent Larrionda!!!”（第X种情况：聪明的拉里昂达！！！）（X从1开始计数）

（我们认为ABCD为球门，AB、BC、CD、DA为球门框，球进了的意思是，球从球门穿过并且未触碰到球门框。）

（可是扯淡的地方在于，门线竟然被当做了球门，我们很无奈，但是要尊重题意（去你妈的题意），没办法，还是把门线当做了门框。

这道题的关键就在于判断球是否从球门进入，而非从侧面或者背面或者上下面进入。）

（但是因为，球在球门内向球门里射这种情况的存在，使这道经典计算几何练习题变成了ws的扯淡题。下面将提到。）

Sample Input：

20 0 5

-10 5 0

10 0 10

10 10 10

10 10 0

10 0 0

0 0 10

0 10 10

0 10 0

0 0 0

（模拟图在上面）

Sample Output：

Case 1: Stupid Larrionda!!!

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3471

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
#include <cctype>
#include <cstdlib>
#include <algorithm>
#include <vector>
#define MAX 1<<30
using namespace std;
const double eps=1e-8;
typedef long long ll;
int main()
{
    typedef struct
    {
    double x;
    double y;
    double z;
    } plus; //三维点坐标的结构。。话说有没有这样的STL啊？
    plus r[100],xa[100],p[100];

//下面是我比赛的时候去恶补的高数知识。。下学期高数没学好啊。几何部分一窍不通。泪目。。。
   /* 面法向量（本题中简易做法是AEvector)

   * 本题中因为给出的是严格长方体，所以ABCD面法向量就是AEvector

   * 下面的法向量求法就没用了，不过学会了更好，我这个数学2B
   * x0=(y2-y1)*(z3-z1)-(z2-z1)*(y3-y1),
   * y0=(z3-z1)*(x2-x1)-(x3-x1)*(z2-z1),
   * z0=(x2-x1)*(y3-y1)-(x3-x1)*(y2-y1)
   * x0*(x-x1)+y0(y-y1)+z0(z-z1)=0

   * 直线参数方程是本题中判断球所在位置的关键
   * 直线参数方程 (p为始点,f为末点，即交点)
   * xf=xp+mt
   * yf=yp+nt
   * zf=zp+qt

   * 以下为求参数方程中t的关键
   * 线面相交方程
   * x0*(xp+mt-x1)+y0*(yp+nt-y1)+z0*(zp+qt-z1)=0
   * (x0*m+y0*n+z0*q)t=(x1-xp)*x0+(y1-yp)*y0+(z1-zp)*z0
   * 参数解法（即，交点确定方法） */

   //  freopen("eg.in","r",stdin);
   //  freopen("fuck3.out","w",stdout);
   int t,i,j,k,ca=0;
   double temp[6],pp[100];//,r[4],l;
   plus o,v,m,f;
   scanf("%d",&t);
   while(t--)
   {
    scanf("%lf%lf%lf",&o.x,&o.y,&o.z);
    scanf("%lf%lf%lf",&v.x,&v.y,&v.z);
    printf("Case %d: ",++ca);
    for(i=0;i<8;i++)
     scanf("%lf%lf%lf",&p[i].x,&p[i].y,&p[i].z);
    m.x=p[4].x-p[0].x;
    m.y=p[4].y-p[0].y;
    m.z=p[4].z-p[0].z; //AEvector

    //将AEvector与速度矢量进行点积，判断速度与法向量是否同向

    //从而判断球是否射向球门内
    if(m.x*v.x+m.y*v.y+m.z*v.z<=eps)
     {
      printf("Intelligent Larrionda!!!\n");
      continue;
     }

    //求由球点与速度矢量确定的直线方程与ABCD及EFGH面的交点

    //temp[0]为与ABCD的交点的参数t的值

    //temp[1]为与EFGH的交点的参数t的值
    temp[0] =( (p[0].x-o.x)*m.x+(p[0].y-o.y)*m.y+(p[0].z-o.z)*m.z )/(m.x*v.x+m.y*v.y+m.z*v.z);
    temp[1] =( (p[4].x-o.x)*m.x+(p[4].y-o.y)*m.y+(p[4].z-o.z)*m.z )/(m.x*v.x+m.y*v.y+m.z*v.z);

    /*判断球是否在球网EFGH的后面

    * 本来我只判断了球是否在球门之后，毕竟题目里说了球初始点不可能在球门内

    * 可是我事后去翻看了标程以及标程数据生成器，果然有这样的数据存在

    * 所以一开始sunyuqi和linyiyong同学竟然能把这道题过了，我表示非常震惊

    * 他们这叫歪打正着呢？还是有先见之明？

    * 学长们，以及我，都被那组不符合题意的数据卡死了。10+的WA。光辉的一B啊！

    * 1W组数据中的100组。被那2B的标程搞死。NND。

    */
    if(temp[0]<=eps&&temp[1]<=eps)
     {
      printf("Intelligent Larrionda!!!\n");
      continue;
     }

    //前面一路判断都为真的话，则求ABCD与射球轨迹的交点
    f.x = o.x + temp[0]*v.x;
    f.y = o.y + temp[0]*v.y;
    f.z = o.z + temp[0]*v.z;

    /*

    * 现在判断交点是否在ABCD面内

    *（严格内部，而非在这个平面上，但不在所包围的区域内）

    * 想法是，求出FAvector，FBvector，FCvector，FDvector（交点在F）

    * 再顺时针对这四个矢量求叉积，叉积即该平面（ABCD）的一侧法向量

    * 再判断这四个法向量是否在同侧即可

    * 判断方法为这四个叉积所得向量进行顺时针点积。均为正，则同向。

    */
    for(i=0;i<4;i++)
    {
     r[i].x = p[i].x - f.x;
     r[i].y = p[i].y - f.y;
     r[i].z = p[i].z - f.z;
    }
    for(i=0;i<3;i++)
    {
     xa[i].x= r[i+1].z*r[i].y-r[i+1].y*r[i].z;
     xa[i].y= r[i+1].x*r[i].z-r[i+1].z*r[i].x;
     xa[i].z= r[i+1].y*r[i].x-r[i+1].x*r[i].y;
    }
    xa[3].x=-( r[3].z*r[0].y-r[3].y*r[0].z);
    xa[3].y=-( r[3].x*r[0].z-r[3].z*r[0].x);
    xa[3].z=-( r[3].y*r[0].x-r[3].x*r[0].y);
    for(i=0;i<3;i++)
     {
      if(xa[i].x*xa[i+1].x+xa[i].y*xa[i+1].y+xa[i].z*xa[i+1].z>0);
      else
       {printf("Intelligent Larrionda!!!\n");break;}
     }
     if(i==3)
      printf("Stupid Larrionda!!!\n");
   }
   //  system("pause");
   //   fclose(stdin);
   //  fclose(stdout);
   return 0;
}
/* 本题，我中间错了无数次。

* 算法一改再改，从一开始判断球与球门的相对位置时计算点面距离，到中间的通过叉积矢量xyz坐标单纯相加判断是否同向，本人对高数以及计算几何进行了各种各样的练习。

* 这还不算上，对于测试文件输入输出的学习，对于标程与自己程序对拍方法的学习。

* 这道题消耗了我一天的时间，但是我觉得值，因为我深入理解了这个问题。虽然不代表我以后遇到这类问题能照AC不误，但至少，我从中收获了不少东西。

* 顺便鄙视一下某些出题人。

* 另外，本人的队友sunyuqi同学，做这题时运用了三维矩阵坐标变换的方法，鉴于本人线性代数超烂，故没学会，也就不摆上来献丑了。等以后学会了再来研究一下不迟。

* 第一次写解题报告，如有错误，烦请指正。

* 感谢各位百忙之中浏览本文。

*/

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 13:08 发表评论

ZOJ 3409 KKV 【高中物理题】

BUPT-[aswmtjdsj] @ Penalty — Tue, 05 Jul 2011 04:56:00 GMT

ZOJ Problem Set – 3409

KKV

Time Limit: 10 Seconds Memory Limit: 65536 KB Special Judge

原题链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3409

算法：模拟题、高中动量守恒公式套上三维模板、计算机模拟手解一元二次方程

题目大意：你从(0,0,0)出发，途中经过N-1个点，最后到达第N个点。(N<=40)

这些点均在三维空间中，这N个点的三维坐标均给出。题目背景是太空中的宇宙飞行，故无重力影响，每个点只靠火箭助推器的喷射来改变速度大小和方向。（而且每次动量守恒求解过程中，保证助推器的速度大小均达到最大。速度根据情况而定）故每个拐点的运动改变方式完全符合动量守恒定律（只不过是三维空间的）。

现给你M，总质量，m1，不含所有燃料的火箭剩余质量（1<=M1）,m0，单块燃料（火箭助推器）的质量，v0，每次喷射时火箭助推器的速度。N个点的坐标。

现求解，从第0个点到第N-1个点都有火箭助推器参与的速度改变过程，故问到第N点时所花费的总时间为多少。若无解，则输出无解时对应的报错语句。

现给出代码及注释：

//解法在注释中给出，分别求解一个一元一次方程和一元二次方程即可

还是在之前模拟一下方程吧。防止看不懂

动量守恒定律基本方程。

m1v1+m2v2=m1v1’+m2v2’

此处分别有两次应用（实际上可以规约为一种应用，但是怕挫，就分成两种了）

第一种是初始点0=(m-m0) * v(x,y,z)+m0 * v0(x,y,z)//v和v0分别为三维速度矢量，v为第一次喷射后剩余火箭箭体的速度矢量，v0为第一次喷射燃料时燃料的速度矢量（所以这其实是三个方程联立，解法为同时两边平方再相加）

式中各参量分别满足v0(x)^2+v0(y)^2+v0(z)^2=v0^2//v0已知

v(x,y,z) = k * vec(x,y,z)//vec(x,y,z)为第0点到第一个点的位移矢量

解得K^2= M0^2*V0^2/(Vec^2*(m-m0)^2), k= sqrt(K^2)

所有值均已知，代入即可解得//vec为vec矢量的模长，v0为标量

第二种为一般情况，针对第i个点（1<=I<=n-1）

M’v’(x,y,z)=(m’-m0)v(x,y,z)+m0v0(x,y,z)//实际上三方程联立

v’即为第i-1个点的速度矢量，v为第I个点的速度矢量，m’为第i-1个点剩余的火箭质量

v(x,y,z)=k * vec(x,y,z)//vec为第i个点到第I+1个点的位移矢量

v0x^2+v0Y^2+v0z^2=|v0|^2

将联立方程组左右平方并加和将常数项移到一侧，从而转化为求解k为主元的一元二次方程问题，化归式如下：

(m’- m0) ^ 2 * |vec| ^ 2 * k ^ 2 – 2 * M’ * (m’- m0) * scalar(v’,vec) * k + m’ ^ 2 * |v’| ^ 2 - m0 ^ 2 * |V0| ^ 2 = 0

一元二次方参数：

A=(M’-m0)^2 * |vec| ^ 2

B=-2*M’*(m’-m0)*scalar(v’,vec)

C=M’^2*|v’|^2-M0^2*|v0|^2

det = b^2 – 4 * a * c

判断det有解与否即可

有解则可由v(x,y,z)=k*vec(x,y,z)知道v的矢量及大小

从而算出ti = |vec| / |v|

将第一段与之后的n-1段的时间即可

#include <iostream>

#include <cstdio>

#include <cmath>

using namespace std;

const double eps = 1e-10;

inline double sqr(double x){return x * x;}

struct point

{

       double x,y,z;

       void input()

       {

              scanf("%lf%lf%lf",&x,&y,&z);

       }

}p[50];

struct vect//矢量定义

{

       double x,y,z,mod;

       void init(point p,point q) //矢量初始化并计算模长

       {

              x = q.x - p.x;

              y = q.y - p.y;

              z = q.z - p.z;

              mod = sqrt(sqr(x) + sqr(y) + sqr(z));

       }

       double cal()//对于速度矢量进行计算速率

       {

              return mod = sqrt(sqr(x) + sqr(y) + sqr(z));

       }

}vec[50],v[50]; //位移矢量和速度矢量

double scalar(vect a,vect b) //点积

{

       return a.x * b.x + a.y * b.y + a.z * b.z;

}

void function(double a,double b,double c,bool &mark,double &k1,double &k2)

{ //求解二次方程专用函数

       double det = sqr(b) - 4.0 * a * c; //delta

       if(det < eps && fabs(det) > eps) //delta<0则无解，无解即对应题目中无解情况

       {

              mark = false;

              return ;

       }

       else if(fabs(det) < eps) //唯一解

       {

              mark = true;

              k1 = k2 = -b / (2.0 * a);

              return ;

       }

       else //二解的话一正解一负解舍弃负解即可（貌似最后算出来delta都等于0？我没测试，大概吧。。。我甚至没去手工模拟一下负解所对应的实际情况是怎样的，就直接否决了，因为负解一定不会符合题意，根据我方程的参数即可知道）

       {

              mark = true;

              k1 = (-b - sqrt(det)) / (2.0 * a);

              k2 = (-b + sqrt(det)) / (2.0 * a);

              return ;

       }

}

void solve(int n)

{

       double m,m1,mt,m0,v0,k,t = 0.0,temp;

       int i;

       scanf("%lf%lf%lf%lf",&m,&m1,&m0,&v0);

       p[0].x = p[0].y = p[0].z = 0.0;

       for(i = 1;i <= n;i++)

       {

              p[i].input();

              vec[i - 1].init(p[i - 1],p[i]); //位移矢量初始化

       }

       //p[0] //对于原点处速度矢量和第一段距离的时间的求解

       /*

          0 = (M-m0)*Vx - m0*V0x //其实可以列一个三元一次方程组用行列式解，我嫌麻烦

          0 = (M-m0)*Vy - m0*V0y //也可以用纯几何的点积叉积做，我不会~算了~

          0 = (M-m0)*Vz - m0*V0z

          (Vx,Vy,Vz) = k * (Vecx,Vecy,Vecz) //求解对象即为k，因为速度矢量方向确定，但是大小不确定，解出大小即可

          V0x^2 + V0y^2 + V0z^2 = V0^2 //V0作为已知量，要做好未知量的化归转化，才方便求出可行解

          t0 = |Vec0| / |V[0]| //标量除法

          t += t0

          */

       mt = m - m0; //第一次后剩余质量

       k = sqrt(sqr(m0) * sqr(v0) / sqr(mt) / sqr(vec[0].mod));

       v[0].x = k * vec[0].x;

       v[0].y = k * vec[0].y;

       v[0].z = k * vec[0].z;

       temp = vec[0].mod / v[0].cal();

       t += temp;

//对于一般点处，求解一般方程

       /*

          ti = |Veci| / |V[i]|

          Mt * Vx[i - 1] = (Mt - m0) * Vx[i] + m0 * V0x

          Mt * Vy[i - 1] = (Mt - m0) * Vy[i] + m0 * V0y

          Mt * Vz[i - 1] = (Mt - m0) * Vz[i] + m0 * V0z

          V[i](x,y,z) = k * Vec[i](x,y,z)

          V0x^2 + V0y^2 + V0z^2 = V0^2

          k^2*|Vec[i]|^2*(Mt-m0)^2 - 2*Mt(Mt-m0)*k*(scalar(Vec[i],V[i-1])) + Mt^2*|V[i-1]|^2 - m0^2*|V0|^2 = 0

          */

       for(i = 1;i < n;i++)

       {

              double k1,k2;

              double a,b,c;

              bool mark = true;

              a = sqr(vec[i].mod) * sqr(mt - m0);

              b = -2.0 * mt * (mt - m0) * scalar(vec[i],v[i - 1]);

              c = sqr(mt) * sqr(v[i - 1].cal()) - sqr(m0) * sqr(v0);

           function(a,b,c,mark,k1,k2);

              if(mark)

              {

                     if(k1 > 0)

                            k = k1;

                     if(k2 > 0)

                            k = k2;

                     v[i].x = k * vec[i].x;

                     v[i].y = k * vec[i].y;

                     v[i].z = k * vec[i].z;

                     temp = vec[i].mod / v[i].cal();

                     t += temp;

              }

              else

              {

                     printf("Another kind of KKV.\n");

                     return ;

              }

              mt = mt - m0;

       }

       printf("%.2lf\n",t);

}

int main()

{

       //freopen("3409.in","r",stdin);

       int n;

       while(scanf("%d",&n) != EOF)

       {

              solve(n);

       }

}

BUPT-[aswmtjdsj] @ Penalty 2011-07-05 12:56 发表评论