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

Question

我试图解决 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);
        }

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

Answer 1

这条线的重点是什么？

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

}

Answer 2

我们可以通过一起避免哈希图来稍微优化空间，但 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;
    }

Answer 3

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

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

Answer 4

import java.io.*;

导入 java.util.*； 导入 java.util.stream.Stream；

公共 class 解决方案 {

public static void main(String[] args) {
    var sc = new Scanner(System.in);
    
    var split = sc.nextLine().split(" ");
    int n = Integer.parseInt(split[0]);
    int m = Integer.parseInt(split[1]);
    
    if (!(1 <= n && n <= 100_000)) {
        System.exit(0);
    }
    if (!(1 <= m && m <= 100_000)) {
        System.exit(0);
    }
    if (!(m <= n)) {
        System.exit(0);
    }
    
    split = sc.nextLine().split(" ");
    
    sc.close();
    int maxNumUniqueInt = 0;
    HashSet<Integer> dist = new HashSet<>();
    Deque<Integer> deque = new ArrayDeque<>();
    int[] arr = Stream.of(split).mapToInt(Integer::parseInt).toArray();
    
    for (int i = 0; i < m; i++) {
        deque.addLast(arr[i]);
        dist.add(arr[i]);
    }
    int num = dist.size();
    if (maxNumUniqueInt < num) {
        maxNumUniqueInt = num;
    }
    for (int i = m; i < n; i++) {
        deque.addLast(arr[i]);
        dist.add(arr[i]);
        int remove = deque.removeFirst();
        if (!deque.contains(remove)) {
            dist.remove(remove);
        }
        num = dist.size();
        if (maxNumUniqueInt < num) {
            maxNumUniqueInt = num;
        }
       // System.out.println(i + "  |  " + deque + "  |  " + dist + "  |  " + maxNumUniqueInt);
    }
    
    System.out.println(maxNumUniqueInt);
}

}

Answer 5

import java.util.*;
public class test {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        Deque<Integer> deque = new ArrayDeque<>();
        int n = in.nextInt();
        int m = in.nextInt();
        int maxUnique = 0;
        Map<Integer, Boolean> uniqSet = new HashMap<>();
        for (int i = 0; i < n; i++) {
          int num = in.nextInt();
           deque.addLast(num);
           uniqSet.put(num, true);
           if(deque.size() == m){
            //  int uniqueSize = new HashSet<>(deque).size();
            int uniqueSize = uniqSet.size();
             maxUnique = Math.max(maxUnique, uniqueSize);
  
             int x = deque.removeFirst();
             if(!deque.contains(x)){
               uniqSet.remove(x);
             }
           }
        }
        in.close();
        System.out.println(maxUnique);
    }
}