如何以 STL 方式查找列表中的最小缺失整数

Question

我想在给定列表中找到最小的缺失正整数。也就是说，如果给定一个正整数列表，即大于 0 且重复的整数，如何从那些缺少最小的那个中找到。

序列中总是至少缺少一个元素。

例如给定

std::vector<int> S={9,2,1,10};

答案应该是 3，因为缺少的整数是 3,4,5,6,7,8,11,...，最小值是 3。

我想出了这个：

int min_missing( std::vector<int> & S)
{
  int max = std::max_element(S.begin(), S.end());
  int min = std::min_element(S.begin(), S.end());
  int i = min;
  for(; i!=max and std::find(S.begin(), S.end(), i) != S.end() ; ++i);
  return i;
}

这是 O(nmlogn) 的时间，但我不知道是否有更有效的 C++ STL 方法来做到这一点？

这不是一个练习，但我正在做一组自我提升的问题，我发现这是一个非常有趣的问题。我有兴趣看看如何改进这一点。

Answer 1

您可以使用std::sort，然后使用带有自定义谓词的std::adjacent_find。

int f(std::vector<int>  v)
{
    std::sort(v.begin(), v.end());
    auto i = std::adjacent_find( v.begin(), v.end(), [](int x, int y) 
    {
        return y != x+1;
    } );

    if (i != v.end())
    {
         return *i + 1;
    }
}

当不存在这样的元素时会发生什么是开放的，例如当向量为空时。

Answer 2

找到第一个缺失的正数，时间为 O(n)，空间恒定

基本上，当您读取值 a 时，只需与 S[a] 交换，就像 2 应该与 A[2] 交换一样

class Solution {
public:
/**    
 * @param A: a vector of integers
 * @return: an integer
 */
int firstMissingPositive(vector<int> A) {
    // write your code here
    int n = A.size();
    for(int i=0;i<n;)
    {
        if(A[i]==i+1)
            i++;
        else
        {
            if(A[i]>=1&&A[i]<=n&& A[A[i]-1]!=A[i])
                swap(A[i],A[A[i]-1]);
            else
                i++;
        }
    }
    for(int i=0;i<n;i++)
        if(A[i]!=i+1)
            return i+1;
    return n+1;
   }
};

Answer 3

假设数据先排序：

    auto missing_data = std::mismatch(S.cbegin(), S.cend()-1, S.cbegin() + 1,
                                      [](int x, int y) { return (x+1) == y;});

编辑 由于您的输入数据未排序，因此最简单的解决方案是先对它们进行排序：

   std::vector<int> data(S.size());
   std::partial_sort_copy (S.cbegin(), S.cend(), data.begin(), data.end());
   auto missing_data = std::mismatch (data.cbegin(), data.cend()-1, data.cbegin()+1,
                                      [](int x, int y) { return (x+1) == y;});

Answer 4

您可以使用标准模板库 c ++ 的算法来处理您的代码。

#include <algorithm>    // std::sort

算法中的这个std::sort：

std::vector<int> v={9,2,5,1,3};

std::sort(v.begin(),v.end());

std::cout << v[0];

我希望我明白你在看什么。

Answer 5

您可以通过构建一组整数并添加在集合中看到的较大的整数，并将未看到的最小值作为计数器来做到这一点。一旦有一个数字等于后者，遍历集合删除元素，直到缺少一个整数。

具体实施请见下文。

template<typename I> typename I::value_type solver(I b, I e)
{
    constexpr typename I::value_type maxseen=
      std::numeric_limits<typename I::value_type>::max();
    std::set<typename I::value_type> seen{maxseen};

    typename I::value_type minnotseen(1);

    for(I p=b; p!=e;++p)
    {
        if(*p == minnotseen)
        {
            while(++minnotseen == *seen.begin())
            {
                seen.erase(seen.begin());
            }

        } else if( *p > minnotseen)
        {
            seen.insert(*p);
        }
    }

    return minnotseen;
}

如果你的序列在一个向量中，你应该使用它：

solver(sequence.begin(),sequence.end());

该算法在时间上为 O(N)，在空间上为 O(1)，因为它只使用一个计数器、固定大小的附加空间和几个迭代器来跟踪最小值。

复杂性（增长率顺序）该算法仅保留输入的子集，该子集预计相对于输入的增长率具有恒定的增长顺序，因此在空间中为 O(1)。迭代的增长率为 O(N+NlogK)，其中 K 是所见较大数字的较大子序列的增长率。后者是上述恒定增长率的子序列，即 K=1 ，这导致算法具有 O(N) 复杂度。（参见 cmets）