Question

想象一下，存在一个巨大的真实数据集：A1，A2，A3，...，Ai，...... An（其中n是一个非常大的数字。）。我想找到这些子数据集，其中这些子集中每个数字之间的差异小于固定值B.并且它必须花费尽可能少的时间和内存。有什么想法吗？

Answer 1

如评论中所述，该集已经排序。让我们调用第i个元素a [i]。一个简单的线性传递查找所有子集（伪代码，不检查数据的结尾 - 这很容易添加，但会模糊算法的想法）：

low = 0;
high = 0;
repeat {
    while (a[high] - a[low] <= B) {
        high = high + 1;
    }
    output set a[low .. high-1];
    while (a[high] - a[low] > B) {
        low = low + 1;
    }
}

请注意，只有low和high之间的部分一次只能在内存中。因此，可以在不将数据全部存储在内存中的情况下流式传输数据。

该算法还将输出一个元素子集。如果不想这样，可以很容易地抑制它。

Answer 2

目前尚不清楚你的意思是多少数据 - 它是否小到可以将所有数据加载到RAM中，无论是否为32位整数，数据中有多少重复，无论是否使用多台机器和/或使用map-reduce工作等。尽管缺乏信息，但我可以盲目地建议你选择Radix sort。它的线性时间排序算法。

编辑1

正如您所提到的，数据已经按升序排序，因此我们可以使用二元搜索（上限）找到每个元素的所有子集。

假设数据容器为A[i]且大小为n，则这是粗略的伪代码：

upper_bound(start, end, key):
    indx := end + 1
    while start <= end do
        mid := start + (end - start) / 2
        if A[mid] >= key:
            indx := mid
            end := mid - 1
        else
            start := mid + 1

     return indx
end


subsets := [] // list of subsets
for i = n - 1 to i = 0 do
    indx := upper_bound(0, i - 1, A[i] - B)
    set := [ elements from A[indx] to A[i] ]
    subsets.push(set)
end

print subsets

对于每个元素arr[i]，您必须找到上限;整体时间复杂度为O(n logn)。

如果需要，我可以提供C ++或Java工作代码段。

编辑2

这是Java代码

import java.util.ArrayList;
import java.util.Arrays;

/**
 *
 * @author kaidul
 */
public class Test {

    private static int upperBound(int left, int right, int key, Integer[] A) {
        int indx = right + 1;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(A[mid] > key) {
                indx = mid;
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return indx;
    }

    public static void main(String[] args) {
        Integer[] A = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int B = 4;
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        for(int i = A.length - 1; i > 0; --i) {
            int startIndx = upperBound(0, i - 1, Math.min(A[i] - B, A[i] - A[0]), A);
            if(startIndx < i) {
                ArrayList<Integer> solutionSet = new ArrayList<>( Arrays.asList( Arrays.copyOfRange(A, startIndx, i + 1) ) );
                result.add(solutionSet);
            }
            if(startIndx == 0) {
                break;
            }
        }
        result.stream().forEach((subset) -> {
            System.out.println(subset);
        });
    }

}

输出：

[7, 8, 9, 10]
[6, 7, 8, 9]
[5, 6, 7, 8]
[4, 5, 6, 7]
[3, 4, 5, 6]
[2, 3, 4, 5]
[1, 2, 3, 4]

搜索彼此之间的差异小于固定值的数字的算法？

2 个答案:

编辑1

编辑2