Java Deque（从子数组中查找唯一整数的最大数目。）

我试图解决JavaDeque上的黑客问题。我的代码通过了除100000个输入之外的所有案例

问题：在这个问题中，给你N个整数。您需要在大小为M的所有可能连续子阵列中找到唯一整数的最大数目。 --->所以我们给N个整数，需要找到每个传染子数组（大小为M）中“唯一整数”的数目。然后打印这些“唯一整数”的最大数目

我的代码：

public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            Deque deque = new ArrayDeque<>();
            HashSet<Integer> set = new HashSet<>();
            int n = in.nextInt();
            int m = in.nextInt();
            int max=0;
            for (int i = 0; i < n; i++) {
                int num = in.nextInt();
                deque.add(num);
                set.add(num);
                if(i>=m-1){
                    if(set.size()>max)max=set.size();
                    Integer removed=(Integer)deque.removeFirst();
                    set.remove(removed);
                   set.add((Integer)deque.peek());
                }
                
            }
            System.out.println(max);
        }

publicstaticvoidmain（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
Deque Deque=新的ArrayDeque（）；
HashSet=newhashset（）；
int n=in.nextInt（）；
int m=in.nextInt（）；
int max=0；
对于（int i=0；i=m-1）{
如果（set.size（）>max）max=set.size（）；
整数removed=（整数）deque.removeFirst（）；
设置。移除（移除）；
set.add（（整数）deque.peek（））；
}
}
系统输出打印项次（最大值）；
}

---

请告诉我我的代码哪里出错了。

这一行有什么意义

                   set.add((Integer)deque.peek());

我在你的代码中没有看到任何慢的东西。我只是想知道，如果一个集合只告诉你是否有这样一个数字（而不是同一个数字出现了多少次），那么如何使用集合来跟踪唯一的数字呢。你也不想一直扫描数据，看看被删除的号码是否是最后一个

我认为这不是很好/很快的代码，但它似乎通过了测试用例。我使用映射（并使用一些代码）来计算窗口中每个整数的数量

import java.util.*；
公共班机{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
Deque Deque=新的ArrayDeque（）；
HashMap计数=新建HashMap（）；
int n=in.nextInt（）；
int m=in.nextInt（）；
int max=0；
对于（int i=0；i=m-1）{
如果（counts.size（）>max）max=counts.size（）；
整数removed=deque.removeFirst（）；
int removing=counts.get（删除）；
删除--；
如果（删除==0）{
计数。移除（移除）；
}否则{
计数。放置（移除、移除）；
}
}
}
系统输出打印项次（最大值）；
}
}

我们可以通过避免使用hashmap来稍微优化空间，但Hackerrank似乎并不在意这一点。任何我如何把我的解决方案放在这里，它可以通过使用地图来解决这个问题

private int countUniqueNumsInSubarrays(int[] nums, int m) {
        Deque<Integer> deque = new LinkedList<>();

        int maxUniqueCount = 0;

        for (int i = 0; i < nums.length; i++) {
            // if deque's left entry is outside the window then pop it out
            while (!deque.isEmpty() && i - deque.peekFirst() >= m) {
                deque.removeFirst();
            }

            // this will make sure that the deque only contains unique numbers,
            // this is essentially helps us avoid that extra hash map  
            while (!deque.isEmpty() && nums[deque.peekLast()] == nums[i]) {
                deque.removeLast();
            }

            deque.addLast(i);

            if (i >= m - 1) {
                maxUniqueCount = Math.max(maxUniqueCount, deque.size());
            }
        }

        return maxUniqueCount;
    }

private int countuniquenumsinsubarray（int[]nums，int m）{
Deque Deque=新链接列表（）；
int maxUniqueCount=0；
对于（int i=0；i=m）{
deque.removeFirst（）；
}
//这将确保deque只包含唯一的数字，
//这基本上帮助我们避免了额外的散列映射
而（！deque.isEmpty（）&&nums[deque.peekLast（）]==nums[i]）{
deque.removeLast（）；
}
deque.addLast（i）；
如果（i>=m-1）{
maxUniqueCount=Math.max（maxUniqueCount，deque.size（））；
}
}
返回maxUniqueCount；
}

谢谢你的建议！！我使用的逻辑是创建一个Deque（大小为M），每次迭代都删除第一个元素（同时在末尾添加新元素）。并将元素添加到集合中，以便它只存储唯一的数字

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Deque<Integer> deque = new ArrayDeque<>();
        HashMap<Integer, Integer> counts = new HashMap<>();
        int n = in.nextInt();
        int m = in.nextInt();
        int max = 0;
        for (int i = 0; i < n; i++) {
            int num = in.nextInt();
            deque.add(num);
            int count = counts.getOrDefault(num, 0);
            counts.put(num, ++count);
            if (i >= m - 1) {
                if (counts.size() > max) max = counts.size();
                Integer removed = deque.removeFirst();
                int removing = counts.get(removed);
                removing--;
                if (removing == 0) {
                    counts.remove(removed);
                } else {
                    counts.put(removed, removing);
                }
            }
        }
        System.out.println(max);
    }

}

private int countUniqueNumsInSubarrays(int[] nums, int m) {
        Deque<Integer> deque = new LinkedList<>();

        int maxUniqueCount = 0;

        for (int i = 0; i < nums.length; i++) {
            // if deque's left entry is outside the window then pop it out
            while (!deque.isEmpty() && i - deque.peekFirst() >= m) {
                deque.removeFirst();
            }

            // this will make sure that the deque only contains unique numbers,
            // this is essentially helps us avoid that extra hash map  
            while (!deque.isEmpty() && nums[deque.peekLast()] == nums[i]) {
                deque.removeLast();
            }

            deque.addLast(i);

            if (i >= m - 1) {
                maxUniqueCount = Math.max(maxUniqueCount, deque.size());
            }
        }

        return maxUniqueCount;
    }