从行组合

Question

我想检查数据的组合是否存在。下面的代码工作正常，但它看起来效率低下。我正在寻找这个问题的一个很好的解决方案。

=sumif(Src, 1, weight )

强文

Answer 1

看起来您只想检查组合是否是数据集的子集...它在数据集中的显示顺序并不重要。这是对的吗？

您的数据集有多大？数据集是在需要时创建还是在整个过程中维护？

如果数据集很大并且在整个过程中都得到维护，那么搜索是否可以保持排序是更容易的。

for (Integer comb : combination) {
    if (Arrays.binarySearch(dataset, comb) < 0) 
        return false; //If any element is not found, return false
    }
}
return true;

如果您可以对组合进行排序，则可以进一步优化组合。

int loc = 0;
for (Integer comb : combination) {
    loc = Arrays.binarySearch(dataset, loc, data.length, comb);
    //Since both are sorted, u can be sure that next element will be 
    //after previous element match
    if (loc < 0) 
        return false;
    }
}
return true;

即使你不能维护一个有序数组，你可以做的一个优化就是去掉那个布尔数组和底部的for循环。算法如下......

boolean isMatch = false;
for (Integer comb : combination) {
    //We will be here in two condition - 
    //  1. first iteration or previous element was found in dataset. 
    //  2. Just set to false to check next element. Reset the flag 
    boolean isMatch = false; 
    for (Integer data : dataset) {
        if (data.equals(comb)) {
            //match found for the current combination element
            isMatch = true;  
            break;
        }
    }
    //This mean one of the combination element is not there. Break out.
    if (!isMatch) break;  
}
return isMatch;

Answer 2

对复杂度为nlog（n）的数据集进行排序。 （快速或合并排序可能？）然后对数据集上的组合数组的每个成员运行二进制搜索。二进制搜索复杂度日志（n）。当你为组合数组的每个成员执行此操作时，复杂性将是nlog（n）。

nlog（n）+ nlog（n）= 2nlog（n），即O（nlogn）。这样你的表现就会增加。

代码

public static boolean combinations(Integer dataset[], Integer combination[]) {

sort(dataset); // quick or insertion sort, nlogn


for (Integer comb : combination) { // n

    if (!binarysearch(dataset, comb)) //logn
       return false;
}  //n*logn = nlogn

return true;} //2nlogn = O(nlogn)

Answer 3

您可以从数组更改为ArrayList并使用containsAll方法。不确定它是否足够有效但会缩短您的代码。

public static void main(String args[]) {
    Integer data[] = {1, 2, 5, 1, 9, 3, 5, 3, 2};
    Integer combination[] = {1,3 ,2};
    System.out.println("Result: " + combinations(data, combination));
}
public static boolean combinations(Integer dataset[], Integer combination[]) {
    List<Integer> data = Arrays.asList(dataset);
    List<Integer> comb = Arrays.asList(combination);
    return data.containsAll(comb);
}

Answer 4

由于您的数据由实现“Comparable”的Integers组成，我建议您利用它并构造一个TreeSet并将所有数据添加到其中。然后，您可以运行contains（）来查找TreeSet中是否存在元素。 TreeSet保证每次添加，删除和包含的log（n）成本。 添加所有元素（n）将花费你n log（n）。 找出'm'元素是否存在将花费你 log（n）。