Leetcode243周赛

第一题：5772. 检查某单词是否等于两单词之和

思路：题目的意思很简单，就是按照规则判断前两个字符加起来能不能等于第三个字符。这里就是利用一个子函数来计算每个字符串对应的值，然后判断是否相等即可。

代码：

class Solution {
    public boolean isSumEqual(String firstWord, String secondWord, String targetWord) {
        return getForStr(firstWord)+getForStr(secondWord)==getForStr(targetWord);


    }
    public int getForStr(String str){
        int t = 0;
        for (char c : str.toCharArray()) {
            t=t*10+(c-'a');
        }
        return t;
        
    }
}

第二题：5773. 插入后的最大值

思路：这题就是需要在一个大整数中插入一个数[1-9]之间，然后返回能够得到的最大数，这边有两种情况，第一个当目标数为正数，那么得到的最大数一定是这个大整数中比插入数小的那个位置，比如531中插入2那么最大的一定是在1的左边，得到5321。负数则相反。

代码：

class Solution {
    public String maxValue(String n, int x) {
        StringBuilder sb = new StringBuilder();
        int flag = 0;
        if (n.charAt(0)!='-'){
            for (int i = 0; i < n.length(); i++) {
                if (n.charAt(i)< (x+'0') && flag==0){
                    sb.append(((x)));
                    flag=1;
                }
                sb.append(n.charAt(i));
            }
            if (flag==0){
                sb.append(((x)));
            }
        }else {
            sb.append(('-'));
            for (int i = 1; i < n.length(); i++) {
                if (n.charAt(i)> (x+'0') && flag==0){
                    sb.append((x));
                    flag=1;
                }
                sb.append(n.charAt(i));
            }
            if (flag==0){
                sb.append((x));
            }
        }
        return sb.toString();
    }
}

第三题：5774. 使用服务器处理任务

思路：这一题可以使用两个优先队列来写，第一个队列用来放闲置的服务器，第二个队列用来放运行中的队列。当任务一个一个进来时，先判断当前时间有没有空闲的服务器，如果没有，这个时候可以把时间线移动到有空闲服务器的时间，然后将第二个队列pop出来任务，然后再将闲置的服务器放到运行队列中。

代码：

class Solution {
    public int[] assignTasks(int[] servers, int[] tasks) {
        //空闲服务器
        PriorityQueue<int []> queue = new PriorityQueue<>(new Comparator<int []>() {
            @Override
            public int compare(int[] o1, int[] o2) {

                if(o1[1]!=o2[1]){
                    return (o1[1]-o2[1]);
                }else {
                    return (o1[0]-o2[0]);
                }
            }
        });
        //运行服务器
        PriorityQueue<int []> time = new PriorityQueue<>(new Comparator<int []>() {
            @Override
            public int compare(int [] o1, int [] o2) {
                if(o1[2]-o2[2]>0){
                    return 1;
                }else{
                    return -1;
                }
            }
        });
        int[] ans = new int[tasks.length];

        for (int i = 0; i < servers.length; i++) {
            queue.add(new int[]{i,servers[i],0});
        }
        int now = 0;
        for (int i = 0; i < tasks.length; i++) {
            if (queue.isEmpty()){
                now = time.peek()[2];
            }
            
            while (!time.isEmpty() && time.peek()[2]<=now){
                queue.add(time.poll());
            }
            
            if (!queue.isEmpty()){
                ans[i] = queue.peek()[0];
                int[] poll = queue.poll();
                poll[2] = now + tasks[i];
                time.add(poll);
            }
            if (now==i){
                now++;
            }
        }

        return ans;
    }
}