86双周t4 6143. 预算内的最多机器人数目 周赛309 t4 6170. 会议室 III

Posted 2022-09-10 钰娘娘ynn

6143. 预算内的最多机器人数目

你有 ​​n​​ 个机器人，给你两个下标从 0 开始的整数数组 ​​chargeTimes​​​ 和 ​​runningCosts​​​ ，两者长度都为 ​​n​​​ 。第 ​​i​​​ 个机器人充电时间为 ​​chargeTimes[i]​​​ 单位时间，花费 ​​runningCosts[i]​​​ 单位时间运行。再给你一个整数 ​​budget​​ 。

运行 ​​k​​ 个机器人 总开销 是 ​​max(chargeTimes) + k * sum(runningCosts)​​​ ，其中 ​​max(chargeTimes)​​​ 是这 ​​k​​​ 个机器人中最大充电时间，​​sum(runningCosts)​​​ 是这 ​​k​​ 个机器人的运行时间之和。

请你返回在 不超过 ​​budget​​ 的前提下，你 最多 可以 连续 运行的机器人数目为多少。

示例 1：

输入：chargeTimes = [3,6,1,3,4], runningCosts = [2,1,3,4,5], budget = 25 输出：3 解释： 可以在 budget 以内运行所有单个机器人或者连续运行 2 个机器人。 选择前 3 个机器人，可以得到答案最大值 3 。总开销是 max(3,6,1) + 3 * sum(2,1,3) = 6 + 3 * 6 = 24 ，小于 25 。 可以看出无法在 budget 以内连续运行超过 3 个机器人，所以我们返回 3 。

示例 2：

输入：chargeTimes = [11,12,19], runningCosts = [10,8,7], budget = 19 输出：0 解释：即使运行任何一个单个机器人，还是会超出 budget，所以我们返回 0 。

提示：

• ​​chargeTimes.length == runningCosts.length == n​​
• ​​1 <= n <= 5 * 1e4​​
• ​​1 <= chargeTimes[i], runningCosts[i] <= 1e5​​
• ​​1 <= budget <= 1e15​​

来源：力扣（LeetCode）

链接：https://leetcode.cn/problems/maximum-number-of-robots-within-budget
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

做题结果

比赛因为翻译问题被坑，当成子序列反悔堆去写了，谁知道连续，写到00:04做出来了，可惜了前三题的12分钟

方法：双指针

1. 有序集合存储值

2. 哈希存储值出现的次数

3. 不断将双指针右移，增加元素，求和，最大值通过有序集合维护

4. 当左指针右移时，移除哈希中的1个，当计数为0时，从有序集合移除

5. 获得当前两个指针之间的元素（i-j+1）,比较出最大值

class Solution 
        public int maximumRobots(int[] chargeTimes, int[] runningCosts, long budget) 
            long sum = 0;
            int ans = 0;
            int n = chargeTimes.length;
            Map<Integer,Integer> cntMap = new HashMap<>();
            TreeSet<Integer> treeSet = new TreeSet<>((a,b)->a-b);
            for(int i = 0,j=0; i < n; i++)
                sum+=runningCosts[i];
                cntMap.put(chargeTimes[i],cntMap.getOrDefault(chargeTimes[i],0)+1);
                treeSet.add(chargeTimes[i]);
                while (j<=i&&sum*(i-j+1)+treeSet.last()>budget) 
                    sum-=runningCosts[j];
                    cntMap.put(chargeTimes[j],cntMap.getOrDefault(chargeTimes[j],1)-1);
                    if(cntMap.get(chargeTimes[j])==0)  treeSet.remove(chargeTimes[j]);
                    ++j;

                
                ans = Math.max(i-j+1,ans);
            
            return ans;
        
    

6170. 会议室 III

给你一个整数 ​​n​​​ ，共有编号从 ​​0​​​ 到 ​​n - 1​​​ 的 ​​n​​ 个会议室。

给你一个二维整数数组 ​​meetings​​​ ，其中 ​​meetings[i] = [starti, endi]​​ 表示一场会议将会在 半闭 时间区间 ​​[starti, endi)​​​ 举办。所有 ​​starti​​ 的值 互不相同 。

会议将会按以下方式分配给会议室：

1. 每场会议都会在未占用且编号最小的会议室举办。
2. 如果没有可用的会议室，会议将会延期，直到存在空闲的会议室。延期会议的持续时间和原会议持续时间相同。
3. 当会议室处于未占用状态时，将会优先提供给原开始时间更早的会议。

返回举办最多次会议的房间 编号 。如果存在多个房间满足此条件，则返回编号 最小 的房间。

半闭区间 ​​[a, b)​​​ 是 ​​a​​​ 和 ​​b​​ 之间的区间，包括 ​​a​​ 但 不包括 ​​b​​ 。

示例 1：

输入：n = 2, meetings = [[0,10],[1,5],[2,7],[3,4]] 输出：0 解释： - 在时间 0 ，两个会议室都未占用，第一场会议在会议室 0 举办。 - 在时间 1 ，只有会议室 1 未占用，第二场会议在会议室 1 举办。 - 在时间 2 ，两个会议室都被占用，第三场会议延期举办。 - 在时间 3 ，两个会议室都被占用，第四场会议延期举办。 - 在时间 5 ，会议室 1 的会议结束。第三场会议在会议室 1 举办，时间周期为 [5,10) 。 - 在时间 10 ，两个会议室的会议都结束。第四场会议在会议室 0 举办，时间周期为 [10,11) 。 会议室 0 和会议室 1 都举办了 2 场会议，所以返回 0 。

示例 2：

输入：n = 3, meetings = [[1,20],[2,10],[3,5],[4,9],[6,8]] 输出：1 解释： - 在时间 1 ，所有三个会议室都未占用，第一场会议在会议室 0 举办。 - 在时间 2 ，会议室 1 和 2 未占用，第二场会议在会议室 1 举办。 - 在时间 3 ，只有会议室 2 未占用，第三场会议在会议室 2 举办。 - 在时间 4 ，所有三个会议室都被占用，第四场会议延期举办。 - 在时间 5 ，会议室 2 的会议结束。第四场会议在会议室 2 举办，时间周期为 [5,10) 。 - 在时间 6 ，所有三个会议室都被占用，第五场会议延期举办。 - 在时间 10 ，会议室 1 和 2 的会议结束。第五场会议在会议室 1 举办，时间周期为 [10,12) 。 会议室 1 和会议室 2 都举办了 2 场会议，所以返回 1 。

提示：

• ​​1 <= n <= 100​​
• ​​1 <= meetings.length <= 105​​
• ​​meetings[i].length == 2​​
• ​​0 <= starti < endi <= 5 * 105​​
• ​​starti​​ 的所有值互不相同

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/meeting-rooms-iii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

做题结果

成功，多任务优先级问题，明显两个堆解决，开始想单个堆还是思路不清晰

方法：双堆

1. 空闲堆：只比编号，取编号最小

2. 占用堆：比较时间和编号，取时间最小编号最小

3. 初始都放在空闲堆中，每次取出根据时间放入占用堆

4. 在会议开始前的所有占用会议室弹出放入空闲堆，如果没有空闲堆，则强制从占用堆再取一个元素

5. 从这些元素中挑出一个占用，并记录结束时间，放入占用堆

class Solution 
        public int mostBooked(int n, int[][] meetings) 
            int m = meetings.length;
            int[][] meetSort = new int[m][3];
            for(int i = 0; i < m; i++)
                meetSort[i][0]=meetings[i][0];
                meetSort[i][1]=meetings[i][1];
                meetSort[i][2]=i;
            
            Arrays.sort(meetSort,(a,b)->a[0]==b[0]?a[2]-b[2]:a[0]-b[0]);
            int[] times = new int[n];
            PriorityQueue<int[]> wait = new PriorityQueue<>((a,b)->a[1]-b[1]);
            for(int i = 0; i < n; i++)
                wait.offer(new int[]0,i);
            
            PriorityQueue<int[]> occupy = new PriorityQueue<>((a,b)->a[0]==b[0]?a[1]-b[1]:a[0]-b[0]);

            int time = 0;
            for(int [] meet:meetSort)
                int s = meet[0];
                int e = meet[1];
                while (!occupy.isEmpty()&&occupy.peek()[0]<=s)
                    wait.offer(occupy.poll());
                
                if(wait.isEmpty())  wait.offer(occupy.poll());
                int []top = wait.poll();
                int curr = Math.max(s,Math.max(time,top[0]));
                top[0]=e-s+curr;
                times[top[1]]++;
                time = Math.max(meet[0],time+1);
                occupy.offer(top);
            

            int ans = 0;
            for(int i = 0; i < n; i++)
                if(times[i]>times[ans]) ans = i;
            
            return ans;