查找数组的最小子序列

Question

我有一个数组，例如{1,2,4,5,6}。我希望我的函数找到最大可能的数字 X 使得 1,2,...,X-1 中的所有数字都在数组中。在这种情况下，X=3。数组中的数字可以从 0 到无穷大。

我的尝试是：

int array(int* t, int r) {
    int* a;
    int m=0;
    int i;

    for(i=0;i<=r;i++){
        a[i]=i;
        if(a[i]==t[i])
            m++;
    }
    return m;
}

我想创建一个从 1 到 r 的数组，这是一个数组的长度，充满自然数，即 {1,2,3...} 。然后我想将它与实际的数组 t 进行比较。如果有匹配的，请寻找另一个。

我不知道为什么它不起作用以及如何解决它？

无论如何代码都不起作用，我仍然不知道如何解决这个问题。

仍在寻找答案。

更新：我做了类似的事情：

int array(int* t, int r) {

for(int x=0;x<r;x++){

    for(int y=0; y<r-1;y++){
        if(t[y]>t[y+1]){
            int temp=t[y+1];
            t[y+1]=t[y];
            t[y]=temp;
        }
    }
}
   for (int i = 0; i != r; i++) {
        if (t[i] != (i + 1)) {
            return i + 1;
        }
    }
    return r + 1;
}

但是，当在输入数组中我在某个地方为零时，例如{5,0,1,2} 函数总是返回 1，不管 0 放在哪里。这是为什么呢？

Answer 1

你不需要额外的数组，你可以迭代直到索引不符合你的期望：

int find_iota_end(const int* a, int size)
{
    std::sort(a, a + size); // if initial array is not sorted.
    for (int i = 0; i != size; ++i) {
        if (a[i] != (i + 1)) {
            return i + 1;
        }
    }
    return size + 1;
}

Answer 2

您的代码存在许多问题

int array(int* t, int r) {
    int* a;
    int m=0;
    int i;

    for(i=0;i<=r;i++){
        a[i]=i;
        if(a[i]==t[i])
            m++;
    }
    return m;
}

• a 未初始化，即它不指向您的程序分配的有效内存。你需要做int *a = new int[r]。 在你的函数返回之前不要忘记delete a
• i 应该上升到 r - 1 而不是 r。所以i < r 而不是i <= r

---

这里有一些伪代码概述了解决这个问题的可能方法。如果找不到有效的起始范围，则结果为零。

伪代码（快速，感谢Kenny Ostrom）

• 让curr = 0
• 让lookup = std::unordered_set<int>
• 将所有元素插入lookup
• 从0 到n，其中n 是元素数组的大小
  • [循环]
    • 如果curr + 1 不在lookup 中，则跳出循环
    • 否则将curr 设置为curr + 1
  • [循环结束]
• 终于返回curr + 1

伪代码（有点快，取决于您的排序算法）

• 对数组进行排序（std::sort 始终是一个不错的选择）
• 将一些变量curr设置为0
• 从 a₀ 到 a_n，其中 a_i 是数组中索引 i处的元素>
  • [循环]
    • 如果curr + 1 不等于a_i 则跳出循环
    • 否则将curr 设置为a_i
  • [循环结束]
• 终于返回curr + 1

伪代码（慢）

• 将一些变量curr设置为0

• 从 a₀ 到 a_n，其中 a_i 是数组中索引 i处的元素>

  • [循环]
    • 从a_j 到a_n 其中j = 0
      • [循环]
        • 如果 curr + 1 等于 a_j 则将 curr 设置为 a_j 并跳出此循环
      • [循环结束]
      • 如果curr没有改变，则跳出这个循环
  • [循环结束]

• 终于返回curr + 1

Answer 3

经过反思，我认为你最初的想法非常接近一个好的算法，如果你修复错误，并完全忽略任何值 a[i] 值不在 [1..r] 范围内。

您必须为第二个向量分配实际内存，并且需要两个独立的循环。如果值相关，则第一个循环填充第二个向量。第二个循环寻找答案。

这给你空间 O(n) 因为你只考虑那么多可能的答案，而时间 O(n) 因为它只是读取长度两次。