春招冲刺百题计划|队列

Java基础复习

1. Java数组的声明与初始化
2. Java ArrayList
3. Java HashMap
4. Java String 类
5. Java LinkedList
6. Java Deque继承LinkedList
7. Java Set
8. Java 队列

第一题：387. 字符串中的第一个唯一字符

class Solution {
    public int firstUniqChar(String s) {
        //最简单的方法就是暴力遍历，时间复杂度在n^2
        // for(int i=0; i<s.length(); i++){
        //     int flag = 1;
        //     for(int j=0; j<s.length(); j++){
        //         if(j!=i&&s.charAt(j)==s.charAt(i)){
        //             flag=0;
        //             break;
        //         }
        //     }
        //     if(flag==1){
        //         return i;
        //     }
        // }
        // return -1;
        //怎么变成n的复杂度呢？就只遍历一次。找一个表存起来
        Map<Character, Integer> frequency = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);//其实还是hash的部分。
        }
        for (int i = 0; i < s.length(); ++i) {
            if (frequency.get(s.charAt(i)) == 1) {
                return i;
            }
        }
        return -1;
    }
}

队列：

class Solution {
    public int firstUniqChar(String s) {
        Map<Character, Integer> position = new HashMap<Character, Integer>();
        Queue<Pair> queue = new LinkedList<Pair>();
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            char ch = s.charAt(i);
            if (!position.containsKey(ch)) {
                position.put(ch, i);
                queue.offer(new Pair(ch, i)); //向链表末尾添加元素，返回是否成功，成功为 true，失败为 false。
            } else {
                position.put(ch, -1);
                while (!queue.isEmpty() && position.get(queue.peek().ch) == -1) {
                    queue.poll();
                }
            }
        }
        return queue.isEmpty() ? -1 : queue.poll().pos;//删除并返回第一个元素。
    }

    class Pair {
        char ch;
        int pos;

        Pair(char ch, int pos) {
            this.ch = ch;
            this.pos = pos;
        }
    }
}

第二题：你可以安排的最多任务数

思路纠正：来自leetcode官方

class Solution {
            //很粗糙的贪心的想法:很明显的逻辑漏洞。
        // Arrays.sort(tasks);
        // Arrays.sort(workers);
        // Boolean[] worked = new Boolean[workers.length];
        // int sum=0;
        // Arrays.fill(worked, false);
        // for(int i=0; i<tasks.length; i++){
        //     for(int j=0; j<workers.length; j++){
        //         if(worked[j]==false&&workers[j]>=tasks[i]){
        //             worked[j]=true;
        //             sum++;
        //             break;
        //         }else if(worked[j]==false&&pills>0&&workers[j]+strength>=tasks[i]){
        //             worked[j]=true;
        //             pills--;
        //             sum++;
        //             break;
        //         }
        //     }
        // }
        // return sum;
    public int maxTaskAssign(int[] tasks, int[] workers, int pills, int strength) {
        //但其实，回归到问题本身，找得是最大的sum。而sum的取值范围是[0, min(tasks.length, workers.length)],然后就二分法查找（非常经典的套路）。
        Arrays.sort(tasks);
        Arrays.sort(workers);
        int min = 0;
        int max = Math.min(tasks.length, workers.length);
        // 二分法
        while (min < max) {
            int mid = (min + max + 1) >> 1;
            if(check(mid,tasks,workers,pills,strength)){//重点在于如何check，求解数学题，已知那么多人，那么多外援，你能不能完成给定的工作量。
                min = mid;
            }else {
                max = mid-1;
            }
        }
        return min;

    }
    public boolean check(int k, int[] tasks,int[] workers,int pills, int strength){

        Deque<Integer> queue = new ArrayDeque<>();
        int index = workers.length - 1;
        //首先，肯定把任务范围给圈定在最小的k个里面。工人选择力量最大的k个来完成。
        for (int i = k - 1; i >= 0; i--) {
            //本轮次的目的是找到最少一个工人能够应付tasks[i]
            int task = tasks[i];
            //把吃了药丸能够完成 当前工作量最大的工作 的 工人 加入队列
            while (index >= 0 && workers[index] + strength >= task) {
                queue.addLast(workers[index]);
                index--;
            }
            //没有一个人能完成 当前工作量最大 的工作
            if (queue.size() == 0) {
                return false;
            }
            //如果有一群人能够完成，那么我们的挑选原则是（选不吃药情况下最大的，或者吃药情况下最小的。）
            if(queue.getFirst() >= task){
                //不需要吃药的情况，让队首工作
                queue.removeFirst();
            }else if(pills -- > 0 ){
                // 需要吃药丸时，让队尾吃药
                queue.removeLast();
            }else {
                return false;
            }

        }
        return true;
    }


}

第三题：最近的请求次数

其实就是维护一个队列而已。

class RecentCounter {
    Deque<Integer> requests = new LinkedList<Integer>();
    public RecentCounter() {
        requests.clear();
    }
    public int ping(int t) {
        requests.addLast(t);
        int min = t-3000;
        int max = t;
        int sum = 0;
        while(!requests.isEmpty()&&requests.getFirst()<min){
            requests.removeFirst();
        }
        return requests.size();

    }
}

/**
 * Your RecentCounter object will be instantiated and called as such:
 * RecentCounter obj = new RecentCounter();
 * int param_1 = obj.ping(t);
 */

第四题：戳印序列

过于难了。官方给出的解法是逆推。