2016 Multi-University Training Contest 3----解题报告

2016 Multi-University Training Contest 3----解题报告

1.HDOJ 5752(1001) Sqrt Bo

        题意呢很简单就是告诉你一个数字，问你能不能在5次之内把这个数字开方出来等于1，但是和真正开始的唯一区别就是开方完以后需要向下取整，实际上就是保留整数部分即可。一开始拿到这个题目时候，都没怎么考虑，直接就用了Java大数，后来发现不会大数的复制操作，然后又直接用了C++的大数模板，过是过了，不过比赛完发现傻逼了，这么简单一道题目至于大数这么复杂吗！！！

       这道题既然要开方等于1，那我们现在反过去推导，假设5次开方以后等于2，2肯定是由4得到的，依次类推，最后得到4294967296，那么实际上就是大于这个的数字都不用考虑了，小于这个的数字由于在long long范围内，所以直接调用sqrt函数即可，判断两个字符串数字的大小关系不能直接使用string的< > 重载符号，因为对于字符串来说9比4294967296更大，所以首先判断长度，短的肯定小，然后如果长度相等，再使用< >进行判断，另外将一个字符串转换成数字，可以使用stringstream。

       代码如下：

string maxn("4294967296");

int main()
{
#ifdef LOCAL
    ///freopen("in.txt", "r", stdin);
    ///freopen("out.txt", "w", stdout);
#endif // LOCAL
    string n;
    while(cin >> n)
    {
        if(n.size() > maxn.size() || (n.size() == maxn.size() && n > maxn))
            cout << "TAT" << endl;
        else
        {
            stringstream in;
            LL num;
            bool flag = false;
            in << n;
            in >> num;

            for(int i = 0; i <= 5; ++i)
            {
                if(num == 1)
                {
                    cout << i << endl;
                    flag = true;
                    break;
                }
                num = (LL)sqrt((double)num);
            }
            if(!flag)
                cout << "TAT" << endl;
        }
    }
    return 0;
}

2.HDOJ 5753(1002) Permutation Bo

        题意就是说h这个序列是1~n的一个全排列，然后对于每一次排列的情况计算，最后将这个函数对于每一次排列的和加起来除以总排列数即可，那么直接这道题实际上代码特别简单，因为这是一个公式题目。

       首先我们换一种思维考虑这个题目式中的关于h的判断，一方面，表示当前这个数字在h序列比左右都大，另一方面表示了ci这个数字选还是不选，所以我们考虑对于整个全

排列的所有情况而言，究竟选了多少个c1, c2, c3,...cn，然后我们加在一起除以全排列的总数n!即可

       我们先来看第一个数字一共可以被选多少次，

        c1想要被选上，那么h1必须大于h2因为，h0是0，所以这里假设h1是1，很明显不可能，假设h1是2，那么h2只能是1了，h3,h4可以随意填写3,4或4,3，假设h1是3，那么h2只能是1或者2了，h3,h4也有两种情况可以填，所以最后的总的结果就是A(n-2, n-2) * ((1 + n - 1)(n - 1) / 2)，由于最后要除以n!，所以这个表达式就是1/2，同理对于最后一个数字cn来说，也是1/2

       中间的数字，需要考虑左右填的数字，那么实际上中间的数字的情况是一样的，最后用同样的方式推导出来为1/3

       实际上这道题的思考方向就是c这个数组里面的每一个数字，会被使用多少次，这就是这道题的思路吧，我觉得，以下代码：

public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    int t;
    int sum, a, b, num;
    DecimalFormat df = new DecimalFormat("0.000000");
    while(cin.hasNextInt()) {
        t = cin.nextInt();
        if(t == 1) {
            num = cin.nextInt();
            System.out.println(df.format(num));
        } else {
            sum = 0;
            a = cin.nextInt();
            for(int i = 1; i < t - 1; ++i) {
                num = cin.nextInt();
                sum += num;
            }
            b = cin.nextInt();
            System.out.println(df.format((a + b) / 2.0 + sum / 3.0)); 
        }
    }
    cin.close();
}

3.HDOJ 5761(1010)

这道题吧，我就想说，心好累。。。。

设船到原点的距离是$r$，容易列出方程

drdt=v2cosθ−v1\frac{ dr}{ dt}=v_2\cos \theta-v_1​dt​​dr​​=v​2​​cosθ−v​1​​

dxdt=v2−v1cosθ\frac{ dx}{ dt}=v_2-v_1\cos \theta​dt​​dx​​=v​2​​−v​1​​cosθ

上下界都是清晰的，定积分一下：

0−a=v2∫0Tcosθdt−v1T0-a=v_2\int_0^T\cos\theta{ d}t-v_1T0−a=v​2​​∫​0​T​​cosθdt−v​1​​T

0−0=v2T−v1∫0Tcosθdt0-0=v_2T-v_1\int_0^T\cos\theta{ d}t0−0=v​2​​T−v​1​​∫​0​T​​cosθdt

直接把第一个式子代到第二个里面

v2T=v1v2(−a+v1T)v_2T=\frac{v_1}{v_2}(-a+v_1T)v​2​​T=​v​2​​​​v​1​​​​(−a+v​1​​T)

T=v1av12−v22T=\frac{v_1a}{{v_1}^2-{v_2}^2}T=​v​1​​​2​​−v​2​​​2​​​​v​1​​a​​

这样就很Simple地解完了，到达不了的情况就是v1<v2v_1< v_2v​1​​<v​2​​（或者$a>0$且v1=v2v_1=v_2v​1​​=v​2​​）。

代码如下：

public static void main(String[] args) {
	Scanner cin = new Scanner(System.in);
	while(cin.hasNextInt()) {
		double a, v1, v2;
		a = cin.nextDouble(); 
		v1 = cin.nextDouble();
		v2 = cin.nextDouble();
		if(a == 0)
			System.out.println("0.0000000000");
		else if(v1 <= v2)
			System.out.println("Infinity");
		else
			System.out.println(new DecimalFormat("0.0000000000").format((a * v1) / ((v1 * v1) - (v2 * v2))));
	}
	cin.close();
}

4.HDOJ 5762(1011) Teacher Bo

        这道题意思就是能不能找到4个点满足 (A,B,C,D)(A<B,C<D,A≠CorB≠D) 并且A,B和C,D之间的曼哈顿距离还要相等（曼哈顿距离就是横纵坐标之差的和），实际上就是找到整个这些点所形成的曼哈顿距离有没有重复

        表面上看数据量是10000，如果O(n*n)会超时，但是实际上肯定不可能出现这种情况，想象一下实际上会出现很多重复的距离的，由于坐标都是整数，我们可以知道一个坐标范围是0~m的坐标系，一共有2 * m种不同的曼哈顿距离，所以我们首先判断一下这n个点有没有绝对的重复（所谓绝对重复，就是说，点特别特别多，不用计算都知道肯定有重复的曼哈顿距离），然后如果不能保证绝对的重复，我们就暴力扫一遍即可，这时候数据量其实特别小，所以总的时间复杂度是O(min{N​2​​,M})，这个原理使用了什么鸽巢原理，表示不懂。

       Java代码如下，妥妥2秒

static final int maxn = 100000 + 5;
static boolean[] vis = new boolean [maxn << 1];   //这里必须乘2，不然会错，曼哈顿距离的最大等于横坐标+纵坐标
static int[] x = new int[maxn];
static int[] y = new int[maxn];

public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    int t;
    int n, m;
    t = cin.nextInt();
    while(t-- > 0) {
        n = cin.nextInt();
        m = cin.nextInt();
        for(int i = 0; i < n; ++i) {
            x[i] = cin.nextInt();
            y[i] = cin.nextInt();
        }
        long nn = n;    //这里要临时转为long（64bit） 因为n * n可能会超过int
        if(nn * (nn - 1) / 2 > m * 2) {
            System.out.println("YES");
            continue;
        }
        Arrays.fill(vis, false);
        boolean flag = false;
        for(int i = 0; i < n && flag == false; ++i) {
            for(int j = i + 1; j < n && flag == false; ++j) {
                int dis = Math.abs(x[i] - x[j]) + Math.abs(y[i] - y[j]);
                if(vis[dis] == false) {
                    vis[dis] = true;    //标记这种距离已经访问过了
                } else {
                    flag = true;
                }
            }
        }
        if(flag == false)
            System.out.println("NO");
        else
            System.out.println("YES");
    }
    cin.close();
}