Question

我们假设我们有 k 固定长度序列 p 。每个序列在 0 到 1.0 范围内具有双重值。为简单起见，我们还假设序列只是数组;在实际实现中，它们将是列表。

现在，算法需要找到最小的索引，其值表示给定序列中的“主要扰乱”。此扰乱可以是 1.0 的值或超过某个阈值的值（例如 0.2 ）。例如，如果从 j-1 移动到 j ，该值会超过阈值，那么我们寻找的索引将是 j-1

1.0的紊乱优先于阈值;例如，如果我们找到与阈值匹配的索引，我们仍应检查包含 1.0 的序列。

最后，算法应该产生导致沮丧的最小索引。我已经快速整理了一些代码来测试这个概念并向您展示我所追求的那种东西。我正在寻找的是一个可能更有效的实现，因为这个算法将被广泛执行。

List<double[]> nearCaptures = new ArrayList<double[]>();
double threshold = 0.2;
double majorUpset = 1.0;
int[] indexes = new int[nearCaptures.size()];
for (int i = 0; i < nearCaptures.size(); i++) {
    int index = 0;
    double[] tempArray = nearCaptures.get(i);
    Arrays.sort(tempArray);
    int tempIndex = Arrays.binarySearch(tempArray, majorUpset);
    if (tempIndex > 0) {
        for (int j = 1; j < nearCaptures.get(0).length; j++) {
            if (nearCaptures.get(i)[j] == majorUpset) {
                index = j-1;
                break;
            }
        }
    } else {
        for (int j = 1; j < nearCaptures.get(0).length; j++) {
            if (nearCaptures.get(i)[j] >= nearCaptures.get(i)[j-1] + threshold) {
                index = j-1;
                break;
            }
        }
    }
    indexes[i] = index;
}
Arrays.sort(indexes);
System.out.println(indexes[0]);

Answer 1

提高性能（和正确性）的一些提示：

在查找majorUpset时，执行排序和二进制搜索，生成O（n log（n））运行时，然后进行线性搜索（for循环）。您可以通过线性搜索来查找是否存在majorUpset。
由于tempArray引用原始数组，因此在排序时会弄乱索引。如果需要排序，请对副本进行排序。但如上所述，您无需排序。
您在循环中多次访问值nearCaptures.get(i)，最好将其存储在本地变量中，就在i循环的开头。

<强>增加：

您可能希望并行执行搜索，因为您可以在任何数组中找到最小的翻转索引后立即停止。

int p = nearCaptures.get(0).length;  // p is the common array length
// search for majorUpset
for(int j = 0; j < p; j++){
  for (double[] arr : nearCaptures) {
    if (arr[j]==majorUpset) return j; // first majorUpset
  }
}
// search for threshold
for(int j = 1; j < p; j++){
  for (double[] arr : nearCaptures) {
    if (arr[j]>arr[j-1]+threshold) return j-1; // first threshold
  }
}

搜索匹配预定义条件的矢量序列中最小索引的算法

1 个答案: