华为机试真题 java 实现最大化控制资源成本2022.11 Q4 新题

Posted 2022-12-11 MISAYAONE

目录

题目

思路

考点

Code

---

题目

公司创新实验室正在研究如何最小化资源成本，最大化资源利用率，请你设计算法帮他们解决一个任务混部问题：有taskNum项任务，每个任务有开始时间（startTime），结束时间（endTime）,并行度（parallelism）三个属性，并行度是指这个任务运行时将会占用的服务器数量，一个服务器在每个时刻可以被任意任务使用但最多被一个任务占用，任务运行完成立即释放（结束时刻不占用）。任务混部问题是指给定一批任务，让这批任务由同一批服务器承载运行，请你计算完成这批任务混部最少需要多少服务器，从而最大最大化控制资源成本。

输入描述：
第一行输入为taskNum，表示有taskNum项任务
接下来taskNum行，每行三个整数，表示每个任务的开始时间
（startTime ），结束时间（endTime ），并行度（parallelism）

输出描述：
一个整数，表示最少需要的服务器数量

示例1 输入输出示例仅供调试，后台判断数据一般不包含示例
输入
3
2 3 1
6 9 2
0 5 1
输出

2

说明
一共有三个任务，第一个任务在时间区间【2，3】运行，占用1个服务
器，第二个任务在时间区间【6，9】运行，占用2个服务器，第三个任
务在时间区间【0，5】运行，占用1个服务器，需要最多服务器的时间
区间为【2，3】和【6，9】，需要2个服务器。

示例2 输入输出示例仅供调试，后台判断数据一般不包含示例
输入
2
3 9 2
4 7 3
输出
5
说明
一共两个任务，第一个任务在时间区间【3，9】运行，占用2个服务
器，第二个任务在时间区间【4，7】运行，占用3个服务器，需要最多
服务器的时间区间为【4，7】，需要5个服务器。

备注：
1<=taskNum<=100000
0<=startTime<endTime<=50000
1<=parallelism<=100

思路

1：题目与第56题【区间交集】非常相似。大致思路应该是不断的递归对区间求交集，求得交集之后将占用机器数相加，直到没有交集为止。

2：举一个比较长的例子：

4

0 5 1
2 3 1

4 7 3
6 9 2

排序后区间为：[0,5] [2,3] [4,7] [6,9]

第一轮两两之间求交集：

[0,5] 和 [2,3] 交集为[2,3] 机器数相加为2

[0,5] 和 [4,7] 交集为[4,5] 机器数相加为4

[0,5] 和 [6,9] 无交集

[2,3] 和 [4,5] 无交集

[2,3] 和 [6,9] 无交集

[4,7] 和[6,9] 交集为[6,7] 机器数相加为5

第二轮两两之间求交集：

[2,3] [4,5] [6,7] 两两之间都没有交集，因此最多的机器数为5。

考点

1：数据结构

2：递归法

Code

import java.util.Scanner;
import java.util.*;

public class Main  
    public static int max_machine=0;

    public static void main(String[] args)  
        //处理输入
        Scanner in=new Scanner(System.in); 
        int taskNum = in.nextInt(); 

        //构造输入数据结构
        ArrayList<ArrayList<Integer>> outerArrayList = new ArrayList<ArrayList<Integer>>();

        for (int i = 0; i < taskNum; i++) 
            int a = in.nextInt();
            int b = in.nextInt();
            int c = in.nextInt();
            ArrayList<Integer> innerArraylist = new ArrayList<Integer>();
            innerArraylist.add(a);
            innerArraylist.add(b);
            innerArraylist.add(c);
            outerArrayList.add(innerArraylist);
        

        //递归求交集
        while (outerArrayList.size() > 1) 
            outerArrayList = cal_public_range(outerArrayList);
        
        System.out.println(max_machine);
    

    public static ArrayList<ArrayList<Integer>> cal_public_range(ArrayList<ArrayList<Integer>> ranges) 
        //先排序 
        Comparator<ArrayList<Integer>> myComparator = new Comparator<ArrayList<Integer>>() 
            @Override
            public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) 
                if (o1.get(0)!=o2.get(0))
                        return o1.get(0)-o2.get(0);
                    else 
                        return o1.get(1)-o2.get(2); 
                    
            
        ;
        Collections.sort(ranges, myComparator);

        //求交集
        ArrayList<ArrayList<Integer>> public_range = new ArrayList<ArrayList<Integer>> ();
        for (int i=0;i<ranges.size();i++) 
            for (int j=i+1;j<ranges.size();j++) 
                int left = Math.max(ranges.get(i).get(0), ranges.get(j).get(0));
                int right = Math.min(ranges.get(i).get(1), ranges.get(j).get(1));
                if (left <= right) 
                    ArrayList<Integer> temp = new ArrayList<Integer>();
                    temp.add(left);
                    temp.add(right);
                    temp.add(ranges.get(i).get(2)+ ranges.get(j).get(2));
                    public_range.add(temp);
                    if (ranges.get(i).get(2)+ ranges.get(j).get(2) > max_machine) 
                        max_machine = ranges.get(i).get(2)+ ranges.get(j).get(2);
                    
                
            
        
        return public_range;