为什么我的算法在子数组（连续）中查找唯一整数的总量，不适用于大量整数和子数组？答案

【问题标题】：Why is my algorithm to find the total amount of unique integers in a subarray (contiguous), not working for larger amounts of Integers and subarrays?为什么我的算法在子数组（连续）中查找唯一整数的总量，不适用于大量整数和子数组？
【发布时间】：2018-02-11 08:33:11
【问题描述】：

我的算法在所有可能的连续子数组中查找唯一整数的最大数量不适用于大量整数和子数组。例如，我必须从控制台读取总共 6 个整数，每个子数组的大小为 3。所以，对于这种输入 5 3 5 2 3 2 我的程序应该打印 3 并且这工作正常。第一个子数组存储 5 3 5，所以唯一整数的数量是 2。第二个子数组存储 3 5 2 所以唯一整数的数量是 3。第三个子数组也会打印 3 因为它存储 5 2 3 等等...

但是，我的算法似乎无法处理 100000 个子数组大小为 99877 的整数。谁能解释一下，我做错了什么？
仅供参考：我必须使用像 LinkedList 或 ArrayDeque 这样的 Deque 实现

for (int i = 0; i < totalAmountOfIntegers; i++) {

    int anyIntegerNumber = consoleInput.nextInt();
    arrayDequeToStoreAllIntegers.addLast(anyIntegerNumber);
    hashSetToStoreUniqueIntegers.add(anyIntegerNumber);

    if (arrayDequeToStoreAllIntegers.size() == sizeOfEachArrayDequeAsSubArray) {

        if (hashSetToStoreUniqueIntegers.size() > quantityOfUniqueIntegersInSubarray) {
            quantityOfUniqueIntegersInSubarray = hashSetToStoreUniqueIntegers.size();
        }

        int firstNumberInDeque = arrayDequeToStoreAllIntegers.remove();
        if (hashSetToStoreUniqueIntegers.size() == sizeOfEachArrayDequeAsSubArray) {
            hashSetToStoreUniqueIntegers.remove(firstNumberInDeque);
        }


    }
}

【问题讨论】：

你在哪里从哈希集中删除值（或重置它）？您目前只计算直到第 n 个元素的不同值（始终从绝对值开始），并且永远不会从散列中删除任何元素。它与使用更大的尺寸无关。您当前的样本还应该为最后一个子数组(2 3 2) 提供错误的结果 3。相同的例如“1 2 3 1 1 1”（带有子尺寸 3）。
是的，你是对的。我还应该从我的 HashSet 变量 hashSetToStoreUniqueIntegers 中删除元素。每次迭代都删除一个元素，还是在每次迭代后重置我的 hashSetToStoreUniqueIntegers 会更好吗？
好吧，因为你不知道散列集本身有多少个“2”（这是你散列集的重点——尽管你可能想测试一个散列图），你有数一下，例如如果您应该从两个变量中删除“2”，则通过计算“arrayDequeToStoreAllIntegers”中“2”的数量。或者每次重置哈希并从“arrayDequeToStoreAllIntegers”重新填充它（参见mumpitz的答案，它就是这样做的）。第一种方法更快，但第二种方法更直接，更容易在其他情况下重复使用。
为了让我们知道您所说的“所有可能的子数组”是什么意思：对于 1,2,3,4,5,6 的主数组，您的意思是元素 1,2,3 ，然后是 2,3,4，然后是 3,4,5 等等，不是您可以构建的任何三元素组合，例如1,2,3; 1,2,4; 1,2,5; ... ; 2,4,6; ...等等，对吧？
是的，我所说的“所有可能的子数组”是指元素 1,2,3，然后是 2,3,4，然后是 3,4,5，最后是 4,5,6

标签： java algorithm hashset arraydeque

【解决方案1】：

答案就是整个数组中唯一的整数，因为数组是所有子数组的超集，所有数字都会出现在其中
只需找出存在多少个独特元素

【讨论】：

是的，为了找出一个子数组中存在多少唯一元素，我创建了一个 HashSet 变量。我将其命名为 hashSetToStoreUniqueIntegers，但它似乎不适用于更大的规模。
为什么你需要一个出队呢？只需简单地使用哈希图，将元素添加到其中，如果它不包含元素则增加 1。
这是一个挑战，你应该使用双端队列

【解决方案2】：

说实话，我不明白你的算法。我真的不明白变量指的是什么（尽管它们似乎是以语义方式命名的）。
但是这个呢：

import java.util.HashSet;
import java.util.Set;

public class UniqueIntegers {

    public static void main(String[] args) {
        UniqueIntegers ui = new UniqueIntegers();

        Integer[][] integers = {
                {3,5,3,4,6},
                {1,6,3,2,4},
                {2,3,4},
                {3,3,6,9,2}
        };

        Set<Integer> unique = ui.uniqueIntegers(integers);

        System.out.println("Unique Integers: " + unique.size());
        System.out.println("Integers: " + unique);
    }


    private Set<Integer> uniqueIntegers(Integer[][] ints){
        Set<Integer> result = new HashSet<Integer>();

        for (Integer[] iSub : ints){
            for (Integer i : iSub){
                result.add(i);
            }
        }

        return result;
    }

}

打印出来：

Unique Integers: 7
Integers: [1, 2, 3, 4, 5, 6, 9]

【讨论】：

问题是我必须使用 ArrayDeque。我正在为我的代码寻找改进。
好的，我误解了你所说的“子数组”的意思。我以为你在谈论多维数组。但是所有子数组中唯一整数的个数不是和整个初始数组中唯一整数的个数一样吗？
不，不幸的是，这并不容易。假设您有一个包含 5000 个数字的数组和一个大小为 10 的子数组。可能有 100 或 5000 个不同的数字。但是每个子数组只能容纳 10 个数字。也许一个子数组由 [1,1,1,1,1,2,2,2,2,2] 或 [1,1,1,1,2,2,2,2,2,3] 组成跨度>
因此，您必须查看每个子数组以及哪个子数组包含不同数字的总数。

【解决方案3】：

经过一天的研究，我发现了我的错误。我的第三个 IF 语句是错误的。我正在比较，如果我的 HashSet 变量的大小等于每个子数组可以容纳的元素的最大大小。
相反，我应该比较，如果我的 int 变量 firstNumberInDeque（我首先从 ArrayDeque 变量中删除）包含另一个具有相同值的 int 变量.因此，如果这是真的，我的 HashSet 变量将保持不变。
但是，如果我的 ArrayDeque 变量不包含另一个与 firstNumberInDeque 值相同的 int，则应该从我的 HashSet 变量中删除 firstNumberInDeque。这是正确的代码：

int firstNumberInDeque = arrayDequeToStoreAllIntegers.remove();
if (!arrayDequeToStoreAllIntegers.contains(firstNumberInDeque)) {
    hashSetToStoreUniqueIntegers.remove(firstNumberInDeque);
}

【讨论】：