LeetCode 933. 最近的请求次数 / 433. 最小基因变化 / 442. 数组中重复的数据

933. 最近的请求次数

2022.5.6 每日一题

题目描述

写一个 RecentCounter 类来计算特定时间范围内最近的请求。

请你实现 RecentCounter 类：

• RecentCounter() 初始化计数器，请求数为 0 。
• int ping(int t) 在时间 t 添加一个新请求，其中 t 表示以毫秒为单位的某个时间，并返回过去 3000 毫秒内发生的所有请求数（包括新请求）。确切地说，返回在 [t-3000, t] 内发生的请求数。
  保证 每次对 ping 的调用都使用比之前更大的 t 值。

示例 1：

输入：
[“RecentCounter”, “ping”, “ping”, “ping”, “ping”]
[[], [1], [100], [3001], [3002]]
输出：
[null, 1, 2, 3, 3]
解释：
RecentCounter recentCounter = new RecentCounter();
recentCounter.ping(1); // requests = [1]，范围是 [-2999,1]，返回 1
recentCounter.ping(100); // requests = [1, 100]，范围是 [-2900,100]，返回 2
recentCounter.ping(3001); // requests = [1, 100, 3001]，范围是 [1,3001]，返回 3
recentCounter.ping(3002); // requests = [1, 100, 3001, 3002]，范围是 [2,3002]，返回 3

提示：

1 <= t <= 10^9
保证每次对 ping 调用所使用的 t 值都 严格递增
至多调用 ping 方法 10^4 次

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

思路

一个简单的滑动窗口

class RecentCounter {
    //滑动窗口
    int idx;
    int count;
    List<Integer> list;
    public RecentCounter() {
        list = new ArrayList<>();
        idx = 0;
        count = 0;
    }
    
    public int ping(int t) {
        list.add(t);
        int left = t - 3000;
        while(list.get(idx) < left){
            count--;
            idx++;
        }
        count++;
        return count;
    }
}

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

433. 最小基因变化

2022.5.7 每日一题

题目描述

基因序列可以表示为一条由 8 个字符组成的字符串，其中每个字符都是 ‘A’、‘C’、‘G’ 和 ‘T’ 之一。

假设我们需要调查从基因序列 start 变为 end 所发生的基因变化。一次基因变化就意味着这个基因序列中的一个字符发生了变化。

• 例如，“AACCGGTT” --> “AACCGGTA” 就是一次基因变化。

另有一个基因库 bank 记录了所有有效的基因变化，只有基因库中的基因才是有效的基因序列。

给你两个基因序列 start 和 end ，以及一个基因库 bank ，请你找出并返回能够使 start 变化为 end 所需的最少变化次数。如果无法完成此基因变化，返回 -1 。

注意：起始基因序列 start 默认是有效的，但是它并不一定会出现在基因库中。

示例 1：

输入：start = “AACCGGTT”, end = “AACCGGTA”, bank = [“AACCGGTA”]
输出：1

示例 2：

输入：start = “AACCGGTT”, end = “AAACGGTA”, bank = [“AACCGGTA”,“AACCGCTA”,“AAACGGTA”]
输出：2

示例 3：

输入：start = “AAAAACCC”, end = “AACCCCCC”, bank = [“AAAACCCC”,“AAACCCCC”,“AACCCCCC”]
输出：3

提示：

start.length == 8
end.length == 8
0 <= bank.length <= 10
bank[i].length == 8
start、end 和 bank[i] 仅由字符 [‘A’, ‘C’, ‘G’, ‘T’] 组成

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

思路

bfs

class Solution {
    public int minMutation(String start, String end, String[] bank) {
        //看数据范围明白是暴力解了
        //从end字符开始改变，如果在bank中有和它相差一个字符的基因，那么就将这些基因入队，并且从set中删除这些基因
        //然后继续判断，直到有一个基因和start相差一个字符就返回轮次

        Set<String> set = new HashSet<>();
        for(String s : bank)
            set.add(s);
        if(!set.contains(end))
            return -1;
        Queue<String> queue = new LinkedList<>();

        queue.offer(end);
        set.remove(end);
        int t = 0;
        while(!queue.isEmpty()){
            t++;
            int k = queue.size();
            while(k-- > 0){
                String temp = queue.poll();
                if(isSame(temp, start))
                    return t;
                Set<String> in = new HashSet<>();
                for(String s : set){
                    if(isSame(s, temp)){
                        queue.offer(s);
                        in.add(s);    
                    }
                }
                for(String s : in)
                    set.remove(s);
            }
        }
        return -1;
    }

    public boolean isSame(String a, String b){
        int diff = 0;
        for(int i = 0; i < 8; i++){
            if(a.charAt(i) != b.charAt(i))
                diff++;
            if(diff > 1)
                return false;
        }
        return true;
    }
}

442. 数组中重复的数据

2022.5.8 每日一题

题目描述

给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数，并以数组形式返回。

你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问题。

示例 1：

输入：nums = [4,3,2,7,8,2,3,1]
输出：[2,3]

示例 2：

输入：nums = [1,1,2]
输出：[1]

示例 3：

输入：nums = [1]
输出：[]

提示：

n == nums.length
1 <= n <= 10^5
1 <= nums[i] <= n
nums 中的每个元素出现 一次 或 两次

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

思路

交换位置

class Solution {
    public List<Integer> findDuplicates(int[] nums) {
        //交换位置
        //将每个数字交换到对应的位置，如果对应位置有相同数存在了，说明重复了
        //但是可以预想到一个问题，就是可能会加入重复的数
        //比如说 1 1 2 2，刚开始遍历到第二个1，会在结果集中加入1，
        //遍历到第一个2时，会和第二个1交换；这样导致再遍历到第三个数，也就是1时，会再加入一次1
        //解决方法就是对于重复的数，都置为-1
        
        List<Integer> res = new ArrayList<>();
        int n = nums.length;
        for(int i = 0; i < n; i++){
            int t = nums[i];
            //如果就在原位，不用管
            if(t == i + 1 || t == -1)
                continue;
            //否则就要交换
            //如果那个位置已经有这个数了，那么就说明是重复的数
            if(nums[t - 1] == t){
                res.add(t);
                nums[i] = -1;
            }
            else{
                swap(nums, i, t - 1);
                i--;
            }
            /*
            for(int j = 0; j < n; j++){
                System.out.print(nums[j] + " ");
            }
            System.out.println();
            */
        }
        return res;
    }

    public void swap(int[] nums, int i, int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

用取反标记

class Solution {
    public List<Integer> findDuplicates(int[] nums) {
        //第二个思路，官解的
        //将nums[nums[i] - 1]这个位置的数进行取反，表示nums[i]出现了一次
        //如果第二次出现了，那么加入结果集
        
        List<Integer> res = new ArrayList<>();
        int n = nums.length;
        for(int i = 0; i < n; i++){
            int t = Math.abs(nums[i]);
            //如果还是大于0的，说明这个nums[i]这个数第一次出现
            if(nums[t - 1] > 0){
                nums[t - 1] *= -1;
            }else{
                res.add(t);
            }
        }
        return res;
    }
}