hdu 4445 crazy tank/HDU 4454 stealing acake/SGU 204 Little jumper

最近几次比赛都有一些与物理公式有关的题，在此做个总结...

HDU 4445 crazy tank

2012 ACM/ICPC Asia Regional - JinhuaD题

题意：一坦克在原点上方高为H的位置，总共有N颗速度不同的子弹，友军坦克与敌军坦克分别在x轴右边的某个区间内（可能重叠），求最多有多少颗子弹能击中敌军坦克且不能有任何一颗子弹击中友军坦克。

 

分析：很明显的物理平抛运动，根据公式计算得落地点的水平距离判断是否在限制的范围内就行了。发射的角度可以为0到180的开区间内任何一个值，那么直接枚举角度就行了，注意精度的控制，至多为0.5且保证能枚举到整数的角度。

这题需要的就是胆量，比赛的时候没敢写，其实不过就是个简单的物理问题！！！其实做题应该就是这样，对于别人都能过的题在保证速度的同时要细心编码，对于那些别人不能过的就应该冷静分析并敢于下手。

 

在枚举角度的时候负数的情况包含在正数的情况内，所以只需要枚举正数的角度就行了。

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#define PI acos(-1)
#define MAX 100010
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;

double g = 9.80;
double l, r, L, R, h;
int ma, cnt, n, flag, tag, cont;
double t1, t2, a, b, d, d1;
double s[210];

int main()
{
    while (scanf("%d", &n), n){
        scanf("%lf %lf %lf %lf %lf", &h, &l, &r, &L, &R);
        for (int i = 0; i < n; i++) scanf("%lf", &s[i]);
        ma = 0;
        for (double i = 0; i < 90; i += 0.5){
            cont = cnt = 0, tag = flag = 1;
            for (int j = 0; j < n; j++){
                a = s[j]*sin(i*PI/180.0), b = s[j]*cos(i*PI/180.0);
                t1 = 2*a/g, t2 = (sqrt(4*a*a+8*g*h)-2*a)/(2*g);
                d = b*(t1+t2), d1 = b*t2;
                if (flag){
                    if (L<=d && d<=R) flag = 0;
                    if (flag && l<=d && d<=r) cnt++;
                }
                if (tag){
                    if (L<=d1 && d1<=R) tag = 0;
                    if (tag && l<=d1 && d1<=r) cont++;
                }
            }
            if (flag) ma = max(ma, cnt);
            if (tag) ma = max(ma, cont);
        }
        printf("%d\n", ma);
    }
    return 0;
}

HDU 4454 stealing acake

2012 ACM/ICPC Asia Regional - HangzhouB题

题意：一只蚂蚁从一点（x，y）出发，求其到达一个给定圆心坐标和半径的圆上一点并回到一个给定顶点位置的矩形上一点的整个路程的最短距离。

 

分析：这个题看似非常复杂，但是分开来看，分析可知一点到矩形上一点的最短距离其实根据两者的相对位置是很容易求解的，那么我们只需要枚举从起点到圆上的每一点的就行了，枚举量很小，直接暴力是最好的解法。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define PI acos(-1)
#define INF 0x3f3f3f3f
typedef long long LL;
using namespace std;
int di[4][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
double x, x2, x3, x4, y, y2, y3, y4, r, ans;
double dis(double x, double y)
{
    if (y > y3){
        if (x < x2) return sqrt((x-x2)*(x-x2)+(y-y3)*(y-y3));
        if (x > x3) return sqrt((x-x3)*(x-x3)+(y-y3)*(y-y3));
        return y-y3;
    }
    if (y < y2){
        if (x < x2) return sqrt((x-x2)*(x-x2)+(y-y2)*(y-y2));
        if (x > x3) return sqrt((x-x3)*(x-x3)+(y-y2)*(y-y2));
        return y2-y;
    }
    if (x < x2) return x2-x;
    return x-x3;
}

int main()
{
    while (scanf("%lf %lf", &x, &y), x || y){
        ans = INF;
        scanf("%lf %lf %lf %lf %lf %lf %lf", &x4, &y4, &r, &x2, &y2, &x3, &y3);
        if (x2 > x3) swap(x2, x3);
        if (y2 > y3) swap(y2, y3);
        for (double i = 0; i <= 90; i += 0.05){
            double a = r*cos(i*PI/180), b = r*sin(i*PI/180);
            for (int j = 0; j < 4; j++){
                double c = x4+a*di[j][0], d = y4+b*di[j][1];
                ans = min(ans, sqrt((x-c)*(x-c)+(y-d)*(y-d))+dis(c, d));
            }
        }
        printf("%.2f\n", ans);
    }
    return 0;
}

SGU 204/ZOJ2340 Little jumper

Andrew AndrewStankevich’s Contest #2 @ACDream D题

题意：如图，一只青蛙从必须从给定的ds点出发，首先越过第一面墙上的洞跳至两面墙的中间某一点，然后从该点出发越过第二个洞跳至给定的df点，问要完成这次任务两次起跳的速度中的较大值最小是多少？

 

分析：这题比前面两个题要难些了，感觉值得一做，结合了物理知识和数学分析能力还有三分查找的方法。（感觉做了之后高中的物理平抛运动学公式全部复习了一遍….）

 

首先：对于一次运动，由相应的运动学公式推导可知速度为45度时一定为最小的时候：设水平速度为Vx，竖直速度为Vy，从起跳点到落地点的水平距离为X，那么Vx*Vy=g*X/2，那么当Vx=Vy时速度最小，求得这个时候到达墙壁时的高度，若越过则速度为sqrt(g*x);

如果碰到墙壁，要使得速度尽量小，那么当高度大于洞上方高度则求得高度恰好为t时的速度，如果小于洞下方高度b的时候求得高度恰好为b时的速度，所以，对于每一个落地点，我们求得两个速度并取其较大者就行了。但是因为速度关于落地点的函数属于凹性函数，我们可以三分查找逼近求解速度的值。

 

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;

double b1, t1, b2, t2, l, ds, df, g;
double check(double b, double t, double x, double s)
{
    double h = s-s*s/x;
    if (b<=h && h<=t) return g*x;
    if (h > t) h = t;
    if (h < b) h = b;
    double Vx2 = g*s*(x-s)*0.5/h;
    return Vx2+g*g*x*x/(4*Vx2);
}
double MAX(double a)
{
    return max(check(b1, t1, a+ds, ds), check(b2, t2, l-a+df, l-a));
}
int main()
{
    while (~scanf("%lf %lf %lf %lf %lf %lf %lf %lf", &b1, &t1, &b2, &t2, &l, &ds, &df, &g)){
        double m, mm, le = 0, ri = l;
        int i = 0;
        while (++i <= 100){
            m = le+(ri-le)/3, mm = ri-(ri-le)/3;
            if (MAX(m) < MAX(mm)) ri = mm;
            else le = m;
        }
        printf("%.4f\n", sqrt(MAX(le)));
    }
    return 0;
}

 

总结：对于这类物理公式题，一般都可直接推导出公式进行暴力求解，但是需要根据数据范围估计下枚举量，因为枚举量太少肯定会WA，枚举量太大就会TLE，这时就需要灵活结合运用高效的查找算法了，而且这类题一般都与小数有关，注意精度的控制..