ZZNU-OJ-2118 -（台球桌面碰来碰去，求总距离）——模拟到爆炸【超时】的不能AC的代码

ZZNU-2118 : 早安晚安，不如我先入土为安

题目描述

spring比较喜欢玩台球，因为看着台球在桌子上碰来碰去很有意思（台球撞壁反弹，入射角等于反射角），每次完美的台球入洞，都能体现他数学天才的能力。机房的大佬们当然不承认spring能力强，而是认为每次都是运气而已。

spring很不服气，但又打不过机房大佬，争执过程中聪明的渣渣宥终于想到了完美的办法，那也就是建立数学模型，交给脸红脖子粗的spring来解决。

题目给出一组（x，y），表示矩形的四个点分别为（0,0）（x，0）（0，y）（x，y），构成一个密闭的矩形，只有一个入口（也是唯一的出口）在原点也就是（0,0），假设一个点在原点按照角度（ay=bx）射入矩形中，所拥有的动能为E，每次接触墙壁并反弹所消耗的动能为W，如果射到除原点以外的三个顶点，将原路返回，并且消耗动能W。忽略摩擦力的影响，求出球在矩阵中运动的位移之和，保留两位有效数字。

输入

输入为六个正整数x，y，a，b，E，W。x,y,a,b均小于2000，E，W属于int

输出

求出球在矩阵中运动的位移之和，保留两位有效数字。

样例输入

复制

1 1 1 1 1 1
1 1 1 1 2 1

样例输出

复制

1.41
2.83

---

模拟了四个小时，WA了，瞬间原地爆炸了；

第二天接着找bug，调了后台数据看了看发现一些细节问题，做了一天的这道题，完整地复习了好多几何的知识点！！

我把超时的代码放着了，纪念一下下。

思路是对的，针对上限E=2*10^9，模拟——时间显然会超限！23333

放一组后台数据，可能会对你有所帮助——

INPUT 

1 3 3 1 17 1

OUTPUT

17.92

---

超时的代码，大部分数据正确——

思路：

1、每一步严格分类讨论，计算出是否撞到源点（第一次例外），是否撞到其他三个顶点——具体是哪一个顶点，是否撞到四条边——具体是那一条边！然后分别根据具体情况，求出相应碰撞时的坐标和反射角等参数，进入下一次循环！

2、初始时，由一个顶点和一个ay=bx的射线方程可以推出这条射线的方程的K和b ,简单的方法就是把它延伸成一条相当长的线段来处理，只需坐标加上M和K*M即可！

3、代码精简了好几次，发现某些思路写的代码其实可以大大省去！

4、还有其他方法也阔以解决，比如：数学方法，相似比方法。

#include <iostream>
#include<stdio.h>
#include<string.h>
#include<string>
#include<algorithm>
#define ll long long
using namespace std;
#include<math.h>
#define N 1008
#define M 10008
#define dinf 1000000.0
double X,Y,a,b,E,W;
const double eps=1e-8;
#define PI 3.14159265358
struct Point
{
    double x,y;
    Point(double x=0.0,double y=0.0):x(x),y(y) {}
} p[5];
typedef Point Vector;
struct line
{
    Point e,f;
    double k,b;
} L0,L[5];

Vector operator-(Point a,Point b)
{
    return Vector(a.x-b.x,a.y-b.y);
}
bool operator==(Point a,Point b)
{
    return (fabs(a.x-b.x)<eps)&&(fabs(a.y-b.y)<eps);
}
double cross(Vector t,Vector f) //计算两个向量的叉乘 之模
{
    return (t.x*f.y-t.y*f.x);
}
double cross1(Point  e, Point  f,  Point  g)///向量ef与向量eg的叉积,左边为负值, 锐角为正值
{
    return cross(f-e,g-e);
}

int factcover(  Point  e,  Point  f,  Point  g,  Point  h)///判断两个线段是否相交, 如果不包括端点 直接<0 包括端点为<=minn(极小值)
{
    if(min(e.x,f.x)<=max(g.x,h.x)&&///要避免某一边的端点值  在另一边的延长线上
            max(e.x,f.x)>=min(g.x,h.x)&&
            min(e.y,f.y)<=max(g.y,h.y)&&
            max(e.y,f.y)>=min(g.y,h.y)&& ///<=也可以；前四行 大大于小， 大大于小， 大大于小， 大大于小
            cross1(e,f,g)*cross1(e,f,h)<0&&   ///两条边相交   端点判断容易出错  便需要两条边同时进行； ///己方向量加一异点, 此行相交时结果为负值或0
            cross1(e,g,h)*cross1(f,g,h)<0)    ///如果两者共点  返回值也是1///轮流己方一点指向两个异点, 此行相交时结果为负值或0
        return 1;          ///0 0 1 1 3 3 4 4 返回0      0 0 9 9 3 3 4 4 返回1
    return 0;              ///0 0 3 3 3 3 4 4 返回1     0 0 3 3 3 3 4 5 返回1
}

void init(double x,double y)     //四个顶点，四条边，初始点p0
{
    p[1]=Point(0,0);
    p[2]=Point(0,y);
    p[3]=Point(x,y);
    p[4]=Point(x,0);

    L[1].e=p[1],L[1].f=p[2];
    L[1].k=dinf;
    L[2].e=p[2],L[2].f=p[3];
    L[2].k=0;
    L[3].e=p[3],L[3].f=p[4];
    L[3].k=dinf;
    L[4].e=p[4],L[4].f=p[1];
    L[4].k=0;

}

double Length(Vector A)     //利用点积求向量长度
{
    return sqrt(A.x*A.x+A.y*A.y);
}

double DisToLine(Point P,Point A,Point B)  //点到直线的距离
{
    Vector v1=B-A,v2=P-A;
    return fabs(cross(v1,v2))/Length(v1);
}
void factk(line &s)   //将线段的边长延伸M倍
{
    s.e.x+=1.0*M;
    s.e.y+= s.k * M;
    s.f.x-=1.0*M;
    s.f.y-= s.k * M;
}
void launch(line &s,Point &p0,int begnum, double &ans)    //反射，并返回碰撞数据
{
    //求触碰边(角落)，返回 反射后的射线S的 p0、k、b系数；
    int flag=0;
                //先检查是否撞到了四个点上，再检查是否撞到了四条边上
    for(int i=1; i<=4; i++)  ///直接拿延长后的射线同四个顶点进行求最短距离，为0的为碰撞角
    {
        if(i!=begnum-4 && DisToLine(p[i],s.e,s.f)<eps)
        {
            flag=i;break;
        }
    }

    if(flag==0)   //本次弹射将撞到 第flag的边上
    {
        for(int i=1;i<=4;i++){  ///先平判断撞到编号为 flAG的 边上
            if(i!=begnum&&factcover(s.e,s.f,L[i].e,L[i].f)==1){
                flag=i;
                break;
            }
         }


        double newk,newb;

   // cout<<" 边:"<<flag;
        if(flag==1||flag==3)  //两条竖着的边
        {
            double x=L[flag].e.x;
            double y=s.k*x+s.b;
            ans+=Length(p0-Point(x,y));
            p0=Point(x,y);

            newk=-1*s.k;
            newb=y-x*newk;
        }
        else  //两条横着的矩形边
        {
            double y=L[flag].e.y;
            double x=(y-s.b)/s.k;
            ans+=Length(p0-Point(x,y));
            p0=Point(x,y);

            newk=-1*s.k;
            newb=y-x*newk;
        }

        s.k=newk;
        s.b=newb;///更新反射后的射线S 的k和b
    }
    else
    {

 // cout<<" 角:"<<flag;
        ans+=Length(p0-p[flag]);
        p0=p[flag];

        s.k=s.k;
        s.b=s.b;///碰撞到四个角后原路返回,k不变！b不变！
    }

}
int main()
{

    while(scanf("%lf",&X)!=EOF)
    {
        scanf("%lf%lf%lf%lf%lf",&Y,&a,&b,&E,&W);
        init(X,Y);
        int Time=0;

        Point p0=Point(0,0);  //初始起点和射线
        line s;
        s.k=b / a;
        s.b=0.0;
        double ans=0.0;

        while(E>0)
        {
           ++Time;
          //  if(Time%100000==0)printf(" Time*1e^5=%d
",Time);
            int begnum=-1;
            for(int i=4; i>=1; i--) //四个角编号为1+4--4+4
            {
                if(p[i]==p0){
                     begnum=i+4;break;
                }

            }
            for(int i=1; begnum==-1&&i<=4; i++) //四条边为1--4
            {
                if(DisToLine(p0,L[i].e,L[i].f)<eps)
                {
                    begnum=i;
                }
            }

         //   printf("beg=%d p0= %lf,%lf  s.k=%lf s.b=%lf total_ans:%lf  ",begnum,p0.x,p0.y,s.k,s.b,ans);
            if(Time>1&&begnum==5)break;///从源点冲出去了

            s.e=p0;
            s.f=p0;//当前射线方程;
            factk(s);//由点扩展成线

            launch(s,p0,begnum,ans);//发射小球，计算出新的碰撞点存入p0中，并更改a,b
            E-=W;//减去动能
        }
        printf("%.2lf
",ans);
    }

    return 0;
}