Question

我在排序时遇到了这个问题，我认为可以通过堆排序或快速排序来排序。

有一个大小为n的整数的数组A，无法直接访问。但是，对于形式为A [i]

class hiddenVector {
        private:
             vector <int> data; // you cannot directly access this in your code since this is a private element
        public:
             int getSize();// it returns a non-negative integer equal to the size of the class member data.
             bool iLessThanj(int i, int j); // returns true if and only if data[i] is strictly less than data[j]

};

Answer 1

您可以创建一个包含隐藏向量索引的新向量，然后使用隐藏向量的公共方法iLessThanj()对它进行排序。最后，浏览排序索引以找到一对相等的元素，它们在排序后是相邻的，iLessThanj(i, i+1) == false仅对它们而言是相邻的。

时间复杂度为O（nlogn），内存为O（n）。

hiddenVector a; // {1, 3, -2, -4, 3, 7} for example
// construct indexes array
std::vector<int> a_ind (a.getSize ());
for (int i = 0; i < a.getSize(); i++)
  a_ind[i] = i;

// now a_ind = {0, 1, 2, 3, 4, 5}
// sort it
std::sort(begin(a_ind), end(a_ind),
      [&a] (int i, int j) { return a.iLessThanj(i, j); }
);
// now a_ind = {3, 2, 0, 1, 4, 5} 
// and it is equal to sequence of indexes in sorted hidden vector

// finally, compute an answer to your problem
std::pair<int, int> res = {};
for (int k = 0; k < a_ind.size()-1; k++) {
  int i = a_ind[k];
  int j = a_ind[k+1];
  if (!a.iLessThanj(i, j)) {
    res.first = i;
    res.second = j;
    break;
  }
}
// now res = {1, 4}

PS 在评论中进行讨论的Speedtest结果（使用-O3编译并运行）：

N      squared_algo sublinear_algo
10     2.259e-07    1.1653e-06 
100    4.8259e-06   8.5859e-06 
1000   0.000218602  0.000118063 
10000  0.0138744    0.000718756 
100000 0.913739     0.00876182

已将全速测试编码为 here

Answer 2

假设A只有一对重复，其余所有元素都是不同的。因此它具有n-1个不同的元素和1个与n-1个元素之一相同的元素。您的任务是识别A中两个相同元素的索引。

您不需要访问元素，当iLessThanj(a, b)返回false并且iLessThanj(b, a)返回false时，索引 a 和 b 是解决方案（当然还有 b ！= a ）

类似：

hiddenVector v;
... initialization of v
int n = v.getSize();

for (int a = 0; a < n; ++a) {
  int b;

  for (b = a+1; b < n; ++b) {
     if (!v.iLessThanj(a, b) && !v.iLessThanj(b, a)) {
       std::cout << "element is the same at indexes " << a << " and " << b << std::endl;
       break;
     }
  }
  if (b < n)
    break;
}

P.S。复杂度为O（n ^ 2），请看另一个答案，它更复杂但复杂度较低

排序查询如何访问私有向量值

2 个答案: