华为优招机试（2021年7月7）

最新推荐文章于 2023-11-30 14:28:44 发布

柠檬の夏

最新推荐文章于 2023-11-30 14:28:44 发布

阅读量5.6k

点赞数 1

分类专栏：笔试&面试文章标签：经验分享

本文链接：https://blog.csdn.net/Us006124/article/details/118654337

版权

笔试&面试专栏收录该内容

4 篇文章 1 订阅

订阅专栏

一、工单调用策略

当小区通信设备上报警时，系统会自动生成待处理的工单，华为工单调度系统需要根据不同的策略，调度外线工程师（FME）上站去修复工单对应的问题。
根据与运营商签订的合同，不同严重程度的工单被处理并修复的时长要求不同，这个要求被修复的时长我们称之为SLA时间。假设华为与运营商A签订了运维合同，部署了一套调度系统，只有1个外线工程师（FME），每个工单根据问题严重程度会给一个评分，在SLA时间内完成修复的工单，华为员工获得工单对应的积分，超过SLA完成的工单不获得积分，但必须完成该工单，运营商最终会根据积分付款。
请设计一种调度策略，根据现状得到调度结果完成所有工单，让这个外线工程师处理的工单处理的工单获得的总积分最多。
假设从耨个调度时刻开始，当前工单数量N，不会产生新的工单，每个工单处理修复耗时为1小时。请设计你的调度策略，完成业务目标。
不考虑外线工程师在小区之间行驶的耗时。
假设有7个工单的SLA时间（小时）和积分如下：

工单编号	SLA	积分
1	1	6
2	1	7
3	3	2
4	3	6
5	2	7
6	2	2
7	6	1
最多可获得15积分，其中一个调度结果完成工单顺序为2，6，3，1，7，5，4（可能还有其他顺序）

输入
第一行为一个整数N，表示工单的数量。
接下来N行，每行包括两个整数，第一个整数表示工单的SLA时间（小时），第二个数表示工单的积分。
输出
输入一个证书表示可以获得的最大积分

样例
输入： 7
1 6
1 7
3 2
3 1
2 4
2 5
6 1
输出 15
提示：工单数量N ≤106
SLA时间 ≤ 7×105
答案的最大积分不会超过2147483647

题解
假设这些工单应该是同时产生的，SLA的计时从某个时间点开始是一直要计时的。每个工单修复花费的都是一个小时，这样的话都是考虑整数就可以了。优先处理SLA小的，SLA相同的话，由于在该一个小时内只能处理一个工单，所以优先选择积分大的工单进行处理，舍弃其余的工单。

import java.util.*;

/**
 * @author Tiffany
 * @version 1.0
 * @Title 机试第一题
 * @Package HW
 * @Date 2021/7/7 18:45
 */
public class Exam1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()){
            int n = sc.nextInt();
            int[][] arr = new int[n][2];
            for (int i = 0; i < n; i++) {
                int key = sc.nextInt();
                int val = sc.nextInt();
                arr[i][0] = key;
                arr[i][1] = val;
            }
            System.out.println(solution(arr));
        }
    }

    private static int solution(int[][] arr) {

        int minSLA = 0;
        int time = 0;
        int score = 0;
        int maxSLA = findMaxSLA(arr);
        while (time < maxSLA) {
            //先找到最小的SLA所在的索引
            List<Integer> minList = findMinKey(arr, minSLA);
            //判断最小索引是否存在
            if (minList.size() <= 0) break;
            //从最小索引列表中取得最小索引
            minSLA = arr[minList.get(0)][0];
            //判断最小的SLA是否超过了已用时间
            if (minSLA < time) {
                //已超过，重新寻找最小的SLA索引列表
                minList = findMinKey(arr, minSLA);
            } else {
                //未超过，寻找积分最多的工单执行
                int[] maxScore = findMaxScore(minList, arr);
                time++;
                score += maxScore[0];
                //执行过的值需要去掉
                arr[maxScore[1]][0] = 0;
                arr[maxScore[1]][1] = 0;
            }
        }

        return score;
    }

    //寻找积分最大工单
    private static int[] findMaxScore(List<Integer> minList, int[][] arrList){
        int maxScore = 0;
        int maxIndex = 0;
        for (int i = 0; i < minList.size(); i++) {

            if (arrList[minList.get(i)][1] > maxScore){
                maxIndex = i;
                maxScore = arrList[minList.get(i)][1];
            }
        }
        return new int[]{maxScore, maxIndex};
    }

    //寻找最大的SLA
    private static int findMaxSLA(int[][] arr){
        int maxSLA = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i][0] > maxSLA){
                maxSLA = arr[i][0];
            }
        }
        return maxSLA;
    }
    //寻找最接近已用时间的最小SLA
    private static List<Integer> findMinKey(int[][] arr, int low){
        List<Integer> list = new LinkedList<>();
        int min = 7*105+1;
        for (int[] ints : arr) {
            if (ints[0] < min && ints[0] > low) {
                min = ints[0];
            }
        }

        for (int i = 0; i < arr.length; i++) {
            if (arr[i][0] == min){
                list.add(i);
            }
        }
        return list;
    }

二、逛动物园

由于疫情影响，动物园进行人流管控，减少人员接触，因此从入口进入之后，只能选择某一条路单项行进，比如：老虎园的编码为1，是自愿的编码为2，猴子园的编码为3，天鹅园的编码为4，而从一个地方到另一个地方有一定的距离，则用一下结构表示：老虎园到狮子园，[1,2,15]，狮子园到猴子园[2,3,7]，猴子园到天鹅园[3,4,9]，现状随机拟定一个景点(S)作为出发点，判断是否可能逛完所有景点(N个)。若不能逛完返回-1，若可以逛完，则返回最长距离。
输入
前面每行表示2各景点的路线和距离，格式如[1,2,15]，表示景点1到景点2可通，距离为15。
倒数第2行为景点总数N，倒数第1行为S表示出发点。
说明

动物园不大，景点数范围为1＜N＜100，两个景点间的距离范围为：[0,100]
两个景点间的路线总条数范围为：[1,5000]
输出
若不能逛完返回-1，若可以逛完，则返回最长距离。
样例1
输入： [1,2,15]
[1,3,7]
[3,4,9]
4
3
输出： -1
解释：由于3只能到达4，无法到达1和2，因此最后结果为-1
样例2
输入： [1,2,15]
[1,3,7]
[3,4,9]
4
1
输出： -1
解释：由于从1出发，能够到达2，3，4。1和2之间的距离之和为15，1、3、4之间的距离之和为16，15＜16，因此最后结果为16
题解
本题类似于货郎问题，解决方法可以采用有向加权图的最长距离为基础，增加判断是否能够到达全部的节点。

三、中国象棋

科科最近在学习中国象棋，今日的目标是钻研马走日，给定一张棋盘，棋盘上的棋子有三种类型，马的起始位置，马要到达的目标位置和其他棋子，其他棋子可能会西安至马的前进路线，限制条件如下：

马走日的路径上不能被绊马脚；
马不能到达有棋子的位置。
科科是个象棋新手，请你帮他计算出到达目标位置至少要走多少步，如果不能到达输出-1.
马每次跳跃最多可以有8个方向，但如果前进方向有棋子，则会被绊马脚。
如下图，马的上方有棋子，则红色图形的点不能到达，五角星的位置是马可以到达的位置。

输入
棋盘宽度w(1≤w≤150)，棋盘高度h(1≤h≤150)
棋局，二维数组char[w][h]
其中，.表示没有棋子，#表示有棋子，H表示马当前的位置，T表示马要到达的位置。
输出
输出一个整数，代表马从H到达T最少需要的步数，没有路径则输出-1。
样例1
输入： 5 13
…H…#
…#…
…#…
.#…
…T#.
输出： 4