2

示例：给定 [1 2 3 10 7 8 9]，我寻找给出 [1 1 1 0 1 1 1] 的算法。

我有一个未排序的数组作为输入。作为输出，我寻找最大的排序选择。

  • 对于“选择”，我的意思是一个长度相同的数组，包含 1 和 0（如果元素被选中）。
  • 对于“排序”，我的意思是所选元素构成一个排序数组 - 在上面的示例中：[1 2 3 7 8 9]。
  • 并且“最大”是指没有排序选择中有更多的 1。

最坏的情况：我必须尝试所有 2^{0,1} 种可能的选择。有没有更快的算法来做到这一点？我不记得 CS 学习中的任何内容，也无法在网上找到任何东西（至少按照我的措辞）。

4

3 回答 3

1

是的，这可以通过动态编程来解决。

您必须创建另一个长度等于给定数组的数组，让我们将其命名为 arr

arr[index] 将存储子数组的最大长度，使得 givenArray[index] 是排序顺序中的最后一个元素，如果从 givenArray[0...index] 考虑数组并且在其后添加 givenArray[index] 的元素。

从 arr 您可以找到子排序数组的最大长度并创建数组。

for (int i = 0;i<givenArray.size(); i++) {

    int after = -1;
    int length = 0;
    for(int j = 0;j<i;j++) {
        if (givenArray[j] < givenArray[i] && length < arr[j].maxLengthTillNow) {
            length = arr[j].maxLengthTillNow;
            after = j;
        }
    }

    arr[i].maxLengthTillNow = length + 1;
    arr[i].after = j;
}

复杂度：n*n

于 2018-07-08T09:37:41.200 回答
0

感谢大家的帮助。这是我最终得到的 Wikipedia 伪代码的 C++ 实现：

/// Return indice of the a longest increasing subsequence.
/// implementation of https://en.wikipedia.org/wiki/Longest_increasing_subsequence
template<class T>
std::vector<size_t> indiceOfLongesIncreasingSubsequence(const std::vector<T>& v)
{
  std::vector<size_t> P(v.size()), M(v.size() + 1);
  size_t L = 0;
  for(size_t i = 0; i < v.size(); ++i)
  {
    // binary search for the largest positive j <= L such that v[M[j]] < v[i]
    size_t lo = 1, hi = L;
    while(lo <= hi)
    {
      size_t mid = (lo + hi)/2;
      if(v[M[mid]] < v[i])
        lo = mid+1;
      else
        hi = mid-1;
    }

    // predecessor of v[i] is the last index of the subsequence of length lo-1
    P[i] = M[lo-1];
    M[lo] = i;

    if(lo > L)
      L = lo;
  }

  // reconstruct the longest increasing subsequence
  std::vector<size_t> ind(L);
  size_t k = M[L];
  for(size_t i = 0; i < L; ++i)
  {
    ind[L-1-i] = k;
    k = P[k];
  }

  return ind;
}

要获得真/假向量，需要：

vector<bool> selection(ind.size(), false);
for(size_t i: ind)
  selection[i] = true;
于 2018-07-10T07:29:35.270 回答
0

在这里，我编写了一个方法maximumSortedSelection，它以元素向量作为输入（如 [1 2 3 10 7 8 9] ）并返回布尔向量，其真/假表示 1/0 表示是否选择答案中的索引（如如 [1 1 1 0 1 1 1] ）。

vector< bool >largestSortedSelection( vector<int>&v ){
int n = v.size(); 
vector< int >selectedLen(n);
vector< int >sortedList;
int maxLen = 1;
for(int i = 0; i<n; ++i){
    int lb = lower_bound(sortedList.begin(),sortedList.end(),v[i])-sortedList.begin();
    if( lb!=(int)sortedList.size() ){
        selectedLen[i]=lb+1;
        sortedList[lb]=v[i];
    }
    else {
        sortedList.push_back(v[i]);
        selectedLen[i]=(int)sortedList.size();
    }
    maxLen =  max( maxLen, selectedLen[i] );
}
int lst = INT_MAX;//assuming maximum element will be less than INT_MAX
int len = maxLen+1;
vector< bool >selection(n,0);
for(int i = n-1; i>=0; --i ){
    if( v[i]<lst && selectedLen[i]+1 == len ){
        selection[i] = 1;
        lst = v[i];
        len--;
    }
  }
  return selection;
}

在这种方法中：

  • selectedLen(i) ：排序列表的最长长度，直到索引-i。

  • sortedList ：以排序递增形式保存元素。

  • selection ：以 0/1 的形式保存答案
  • sortedList 中的 lower_bound 函数：返回大于或等于的第一个元素。

如果您对理解源代码有困难，请告诉我。
因为我在一个循环中使用了 N 次 lower_bound 函数（其复杂度为 logN ）。因此，整体时间复杂度为：O(N logN)。
内存复杂度将为O(N)，因为我使用内存来保存 N 个元素。

于 2018-07-10T06:07:01.090 回答