Leetcode 1606. 找到处理最多请求的服务器

传送门:力扣

序 

第一次写的代码,提交后超时了.想法是用一个state数组记录每个服务器最后一个请求结束的时间.依次遍历每个请求,找到请求运行的服务器并修改服务器最后一个请求结束时间.每当一个请求到来时,最坏情况会遍历所有的服务器.时间复杂度为O(k*req_len),req_len为请求个数.

class Solution {
    public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
        // 记录k个服务器的状态,0为空闲,大于1为繁忙,记录上一次结束时间
        int[] state = new int[k];
        //记录k个服务器的访问数量
        int[] count = new int[k];
        int max = 0;
        int req_count = arrival.length;
        //分别处理每个请求
        for(int i = 0;i<req_count;i++){
            int arrival_time = arrival[i];
            int load_time = load[i];
            int serve = getServe(i,state,k,arrival_time);
            if(serve!=-1){
                state[serve]=load_time+arrival_time;
                count[serve]++;
                max = Math.max(max,count[serve]);
            }
        }
        List<Integer> list = new ArrayList<>();
        for(int i = 0;i<k;i++){
            if(count[i]==max){
                list.add(i);
            }
        }
        return list;
    }
    public static int getServe(int i,int[] state,int k,int cur_time){
        if(state[i%k]<=cur_time){
            return i%k;
        }
        for(int j = (i+1)%k;j!=i%k;j=(j+1)%k){
            if(state[j]<=cur_time){
                return j;
            }
        }
        return -1;
    }
}

看了官方题解后,对查询请求运行于哪个服务器做出了优化.使用的是有序集合和优先队列.

TreeSet

底层TreeMap,Entry为树的节点,元素有序存入数中.

测试几个方法:

public class Main {
	public static void main(String[] args) {
		TreeSet<Integer> treeSet = new TreeSet<Integer>((a,b)->a-b);
		treeSet.add(2);
		treeSet.add(1);
		treeSet.add(5);
		treeSet.add(3);
		System.out.println("treeSet.first(): "+treeSet.first());
		System.out.println("treeSet.last(): "+treeSet.last());
		System.out.println("treeSet.ceiling(3): "+treeSet.ceiling(3));
		System.out.println("treeSet.floor(3): "+treeSet.floor(3));
		System.out.println("treeSet.lower(3): "+treeSet.lower(3));
		System.out.println("treeSet.higher(3): "+treeSet.higher(3));
	}
}

输出结果:

treeSet.first(): 1
treeSet.last(): 5
treeSet.ceiling(3): 3
treeSet.floor(3): 3
treeSet.lower(3): 2
treeSet.higher(3): 5

ceiling(),floor()取等,lower(),higher()不取等.

PriorityQueue

堆结构

官方的代码

方法一

class Solution {
    public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
        TreeSet<Integer> available = new TreeSet<Integer>();
//将服务器全部添加到available中,用TreeSet存储可用服务器,当要查找下一个服务器是可调用ceiling()方法查找,时间复杂度O(log(n))
        for (int i = 0; i < k; i++) {
            available.add(i);
        }
//busy存储运行中的请求并根据结束时间排序
        PriorityQueue<int[]> busy = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);
//request记录各服务器访问次数
        int[] requests = new int[k];
//遍历请求
        for (int i = 0; i < arrival.length; i++) {
//当前时间为 arrival[i] 将该busy中结束时间在该时间之前的元素弹出,加入到avaible序列中
            while (!busy.isEmpty() && busy.peek()[0] <= arrival[i]) {
                available.add(busy.poll()[1]);
            }
//无可用服务器,直接丢弃该请求
            if (available.isEmpty()) {
                continue;
            }
//获得该请求运行的服务器
            Integer p = available.ceiling(i % k);
            if (p == null) {
                p = available.first();
            }
            requests[p]++;
//将该请求加入到busy中,同时从avaible中移除该服务器
            busy.offer(new int[]{arrival[i] + load[i], p});
            available.remove(p);
        }
//获取流的最大值
        int maxRequest = Arrays.stream(requests).max().getAsInt();
        List<Integer> ret = new ArrayList<Integer>();
        for (int i = 0; i < k; i++) {
            if (requests[i] == maxRequest) {
                ret.add(i);
            }
        }
        return ret;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/find-servers-that-handled-most-number-of-requests/solution/zhao-dao-chu-li-zui-duo-qing-qiu-de-fu-w-e0a5/
来源：力扣（LeetCode）

 方法二

class Solution {
    public List<Integer> busiestServers(int k, int[] arrival, int[] load) {
        PriorityQueue<Integer> available = new PriorityQueue<Integer>((a, b) -> a - b);
        for (int i = 0; i < k; i++) {
            available.offer(i);
        }
        PriorityQueue<int[]> busy = new PriorityQueue<int[]>((a, b) -> a[0] - b[0]);
        int[] requests = new int[k];
        for (int i = 0; i < arrival.length; i++) {
            while (!busy.isEmpty() && busy.peek()[0] <= arrival[i]) {
                int id = busy.peek()[1];
                busy.poll();
                available.offer(i + ((id - i) % k + k) % k); // 保证得到的是一个不小于 i 的且与 id 同余的数
            }
            if (available.isEmpty()) {
                continue;
            }
            int server = available.poll() % k;
            requests[server]++;
            busy.offer(new int[]{arrival[i] + load[i], server});
        }
        int maxRequest = Arrays.stream(requests).max().getAsInt();
        List<Integer> ret = new ArrayList<Integer>();
        for (int i = 0; i < k; i++) {
            if (requests[i] == maxRequest) {
                ret.add(i);
            }
        }
        return ret;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/find-servers-that-handled-most-number-of-requests/solution/zhao-dao-chu-li-zui-duo-qing-qiu-de-fu-w-e0a5/
来源：力扣（LeetCode）

优先队列实现avaiable和busy,基本思想一样.

总结

TreeSet和Priority结合使用代替数组,将时间复杂度从n将为log(n),本题中,时间这一特征是有序的,或者说不同请求的结束时间的有序的,因此可以用树结构存储.

获取流的最大值

一段感觉很实用的代码.

int maxRequest = Arrays.stream(requests).max().getAsInt();

其中requests为一个数组.