2.2 华为-软件工程师-7.21笔试题

Posted 2021-10-05 尚墨1111

文章目录

• • 2.2 华为-软件工程师-7.21笔试题
  • • 2.2.1 编程一：资源占用
    • 2.2.2 编程二：贪心+小根堆
    • 2.2.3 编程三：图

2.2 华为-软件工程师-7.21笔试题

2.2.1 编程一：资源占用

1、同时运行的出租车数量

方法一：【活动安排问题】253. 会议室 II

1、假定你知道活动安排问题。

2、活动安排问题是指，一个共享会议室，安排了k个活动，每个活动都有起始时间startTime和结束时间endTime。当然这k个活动有重叠，没有重叠就能安排k个活动，求最大安排的活动数量？

3、把这个思想放在这里，假如这k个APP请求，最多相容安排数量为ans，换句话说，这ans个请求只需要1辆车。

4、将步骤3中的APP请求剔除，再一次执行 最多相容安排问题，又需要1辆车

5、 直到ans为0，轮询的次数就是答案。

方法二：

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int K = sc.nextInt();
        int[][] person = new int[K][3];

        int res = 0;
        for(int i = 0; i < K; i++){
            person[i][0] = sc.nextInt();
            person[i][1] = sc.nextInt();
            person[i][2] = sc.nextInt();
        }

        for(int i = 0; i <= 1000; i++){//起始时间，对每一个起始时间进行判断同时在的数量
            int temp = 0;//记录每个发车时间的最大汽车数
            for(int j = 0; j < K; j++){//遍历乘客的数量
                int pos1 = person[j][1];//上车站点
                int pos2 = person[j][2];//下车站点
                int diff = Math.abs(pos1 - pos2);//环形路线需要处理
                int num = Math.min(diff, N - diff);//走更短的路径
                if(person[j][0] <= i && i < person[j][0] + num * 5)//当前车正在运行
                    temp++;
            }
            res = Math.max(res, temp);
        }
        System.out.println(res);
    }
}


站点数，人数
50 3
使用车辆的起始时间 上车 下车
0 0 5
10 10 11
25 20 40
output: 2

10 3
0 0 1
5 0 9
10 0 1
output: 1

15 8
0 6 12
5 0 3
15 5 7
15 8 13
20 12 15
25 7 11
30 0 11
40 5 8
output: 4

    

2.2.2 编程二：贪心+小根堆

生产调度问题——贪心+小根堆

1、按照题目的优先级对数组排序

2、 由于机器数量n有限制，如果没有限制，那么最长时间就是最长的那个任务

3、 机器少任务多的情况

• 一个优先队列 minHeap 存下前n个任务，因为只有n个机器
• 之后，遍历的每个时长加在 minHeap 数组的最小值上
• 结果就是数组的最大值

public static void main(String[] args){
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();//仪器数
    int K = sc.nextInt();//需要使用仪器的设备数

    int[][] nums = new int[K][2];//[使用时间、优先级]，数字越小，优先级越高越先使用，优先级相同使用时间长先使用
    //<按照第二列升序排序，相同按照第一列降序
    for(int i = 0; i < K; i++){
        nums[i][0] = sc.nextInt();
        nums[i][1] = sc.nextInt();
    }
    Arrays.sort(nums,(a,b) -> (a[1] == b[1] ? b[0] - a[0] : a[1] - b[1]));

    //<机器足够多,直接返回任务时间最长的任务
    if (N >= K) {
        int ans = 0;
        for (int i = 0; i < K; ++i)
            ans = Math.max(ans, nums[i][0]);
        System.out.println(ans);
    }

    PriorityQueue<Integer> minHeap = new PriorityQueue<>(N);
    //入栈小顶堆
    for (int i = 0; i < N; i++) {
        minHeap.offer(nums[i][0]);
    }
    //        遍历剩下的，将当前值加到堆顶元素
    for (int i = N+1; i <K; i++) {
        int temp = minHeap.peek()+nums[i][0];
        minHeap.offer(temp);
    }
    //        结果就是堆里面的最大值
    int res = 0;
    for (Integer integer : minHeap) {
        res = Math.max(integer,res);
    }
    System.out.println(res);
}

#if 0
3 7
1 1
4 1
5 3
4 2
2 1
3 3
2 1
output: 8

2.2.3 编程三：图

3 求解图中最大的路径长度

import java.util.*;
public class Main{
    static class Node{
        int target;//目标节点
        int weight;//权重

        public Node(int t, int w){
            target = t;
            weight = w;
        }
    }
    static Map<Integer, ArrayList<Node>> map;
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        // 用一个map将图存起来
        map = new HashMap<>();
        while(sc.hasNext()){
            int start = sc.nextInt();
            int target = sc.nextInt();
            int weight = sc.nextInt();
            Node node = new Node(target, weight);
            ArrayList<Node> list = map.getOrDefault(start, new ArrayList<>());//用list来存图
            list.add(node);
            map.put(start, list);
        }
        int res = 0;
        Main main = new Main();
        // 对每一个结点dfs找出最大路径和
        for(int key : map.keySet()){
            int len = main.dfs(key, 0);
            res = Math.max(res, len);
        }
        System.out.println(res);
    }

    public int dfs(int start, int len){
        if(!map.containsKey(start)) {
            return len;
        }
        int res = 0;
        ArrayList<Node> list = map.get(start);
        for(int i = 0; i < list.size(); i++){
            Node node = list.get(i);
            int t = node.target;
            int w = node.weight;
            res = Math.max(res, dfs(t,len + w));
        }
        return res;
    }
}

输入：[[1,2,5],[1,3,5],[2,5,5],[3,7,10],[3,4,10],[4,2,10],[4,7,5],[5,6,5],[6,7,5]]
output: 40