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

Posted 2023-02-14

【中文标题】Java Deque（从子数组中查找唯一整数的最大数量。）

【英文标题】：Java Deque (Finding the max number of unique integers from subarrays.)

【发布时间】：2021-03-07 01:09:41

【问题描述】：

我试图解决 Java Deque 上的 HackerRank 问题。除了有 100,000 个输入的案例之外，我的代码通过了所有案例。

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

link: https://www.hackerrank.com/challenges/java-dequeue/problem

我的代码：

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);
        

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

【参考方案1】：

只是想分享我如何解决它以防万一。

public static void main(String[] args) 
    Scanner in = new Scanner(System.in);
    Deque deque = new ArrayDeque();
    Set<Integer> integers = new HashSet<>();
    int n = in.nextInt();
    int m = in.nextInt();
    long result = 0;
    for (int i = 0; i < n; i++) 
        int num = in.nextInt();
        deque.add(num);
        integers.add(num);
        if (deque.size() == m) 
            long currentSize = integers.size();
            if (currentSize > result) 
                result = currentSize;
            
            Integer removed = (Integer) deque.pollFirst();
            if (!deque.contains(removed)) 
                integers.remove(removed);
            
        
    
    System.out.println(result);

【参考方案2】：

我们可以通过避免使用 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;
    

【参考方案3】：

这条线的意义何在？

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

我没有在您的代码中看到任何缓慢的内容。我只是想知道如何通过使用集合来跟踪唯一数字，因为集合只告诉您是否存在这样的数字（而不是相同数字的出现次数）。而且您不想继续扫描双端队列以查看被删除的数字是否是最后一个。

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

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);
    

【讨论】：

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