大疆19年校招0804笔试A卷

大疆笔试（客户端，Android），12道不定向选择。难度适中。三道编程，难度适中，照着3号的网易确实简单了不少。至少大多数是有思路的。

笔试题一：咖啡的香气

小名要调N个bug，喝一杯咖啡可以加速一个小时中调bug的速度A倍，一个小时内重复喝无效。一天最多工作八小时。每个bug初始的所需时间是 t1,t2,t3,…tn分钟。问是否可以解完所有的bug。

输入：
输入包含多组测试数据。每组测试数据：
第一行输入三个整数：N、A、X，分别代表需要解决的bug数量、喝咖啡之后效率提升的倍数、一天最多可以喝掉的咖啡数
第二行输入N个整数，表示在不喝咖啡的情况下解决这些八阿哥所需的时间t1, t2, …, tN
输出：
如果能在八小时内解决这些bug(如果时间为小数，向上取整)，输出解决bug的时间，否则输出0

case:input:
8 2 8
60 60 60 60 60 60 60 60
4 3 3
333 77 100 13
output:
240
175

题目分析

这个题目可以过来想：喝一杯咖啡可以在一小时内加速A倍的调试速度，也可以理解成将时间延长A倍。故，只要是·所有的bug的总时长小于等于 X杯咖啡 * A倍加速 * 60 + （8 - X）* 60 ;就一定可以调完，反之调不完。

1. 若是·所有的bug的总时长小于等于 X杯咖啡 * A倍加速 * 60 ，则总时长是 alltime / A（需注意不足一分钟的要进一位）
2. 若是·所有的bug的总时长大于 X杯咖啡 * A倍加速 * 60 ，则总时长是 alltime - X * 60 * A + X * 60（喝咖啡的几个小时全部用光了，再加上不够的必须按原时间调bug的时间）

代码实现

//AC
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int N, A, X;
        while (in.hasNext()) {
            N = in.nextInt();
            A = in.nextInt();
            X = in.nextInt();
            int alltime = 0;
            for (int i = 0; i < N; i++) {
                alltime += in.nextInt();
            }
            if (alltime <= X * 60 * A + (8 - X) * 60) {
                if (alltime <= X * 60 * A) {
                    if (alltime / A * A < alltime) {
                        System.out.println(alltime / A + 1);
                    } else
                        System.out.println(alltime / A);
                } else {
                    alltime = alltime - X * 60 * A + X * 60;
                    System.out.println(alltime);
                }
            } else
                System.out.println("0");
        }
    }
}

笔试题二：应该吃哪个呢

小明在购物架买东西，每个格子放着一种物品，上面标记价格，数目和满意度，小名总共有T的钱，他希望在T以内获得最大的满意度。零食必须整数倍购买，个数有限，卖完就没了。

输入：
输入包含多组测试数据，每组数据：
第一行输入两个整数T、N，分别代表钱数和零食种类数。
接下来的N行，每行输入三个整数ai, bi, ci(1 <= i <= N) ，代表零食的价格、零食的满意度、零食的数量
输出：
求出最大满意度

case:input
100 2
1 1 1
1 1 1
100 3
26 100 4
5 1 4
5 2 2
output
2
306 

题目分析

贪心算法，按照每单位价格的满意度进行排序，从大到小进行购买，直到遍历完所有的商品或者是T减为零。
这个题不知道为啥只过了50%，不知道哪里出了问题。

代码实现

//only pass 50%
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        class Food implements Comparable<Food> {
            int money;
            int value;
            int num;
            float count;

            public Food(int m, int v, int n) {
                this.money = m;
                this.value = v;
                this.num = n;
                this.count = (float) value / money;
            }

            @Override
            public int compareTo(Food o1) {
                if ((this.count - o1.count) >= 0)
                 //这个地方排序相差0.X的话也会变成返回零，表示相等，感觉大概率是这个问题，不过没法子去验证了
                 //写这一块之前还想着别忘了这个，写着写着就给忘了，改的话，大于零返回1，等于零返回0；
                    return (int) (this.count - o1.count);         
                else
                    return -1;
            }
        } 
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int n = in.nextInt();
            int t = in.nextInt();
            boolean has = false; //是否购买
            Food foods[] = new Food[n];
            int allmoney = 0;
            int allvalue = 0;
            for (int i = 0; i < n; i++) {
                int money = in.nextInt();
                int value = in.nextInt();
                int num = in.nextInt();
                foods[i] = new Food(money, value, num);
                allmoney += money * num;
                allvalue += value * num;
            }
            if (allmoney <= t)
                System.out.println(allvalue);
            else {
                allvalue = 0;
                Arrays.sort(foods, 0, n);

                for (int i = n - 1; i >= 0; i--) {
                    int temp = foods[i].num;
                    for (int j = 0; j < temp; j++) {
                        if (t >= foods[i].money) {
                            has = true;
                            t -= foods[i].money;
                            allvalue += foods[i].value;
                            foods[i].num--;
                        }
                    }
                    if (t == 0)
                        break;
                }
                if (has)
                    System.out.println(allvalue);
                else
                    System.out.println("0");
            }
        }
    }
}

笔试题三：机器人大战

是一个单源最短路径算法问题，当时看到题目就退缩了。只大概的记录一下题目，没有代码实现。
N个路标从 1 到 N-1，机器人S只能沿直线从两个路标之间移动，且部分路标间不通。
S从0出发，裁判随机给出一个路标，要求S以最快速度到达。每轮都从0开始。用时最短的获胜。
每两个路标至少存在一条路径可以到达。
写程序实现。

输入：
第一行 N，P，C 三个数据，分别代表 路标个数，可以移动的路标的道路的数目，以及比赛的轮数。
接下来P行，每行三个整数 A，B，T，分别表示A到B所需的时间T。
接下里C行。每行一个正整数X ，表示每轮需要到达的路标编号。

输出：
输出C行，每行输出总时间最短是多少。

题目分析

应该使用 迪杰斯特拉算法 或者是 弗洛伊德算法 ，时间紧张没有调通。代码不贴了。

后记

还要接着练，还差得远了啊，加油！！！