找到最相似值的有效方法

Question

我有一个值，例如颜色，以及一个字符串列表：{颜色、颜色、主颜色、主颜色、主题、品牌、主题.....等}

我想得到最相似的字符串，除了搜索的字符串本身。在这个例子中，期望得到颜色。 （不是颜色）

我正在对列表进行排序 我正在使用以下规则并对规则进行排名：

1. 过滤相同的值
2. 检查大小写
3. 删除空格。修剪
4. 使用 Levenshtein 距离
5. 字符串顺序：主色 = 主色
6. 检查首字母缩略词：HP - Hewlett Packard

查看包含 1000 名相关候选人的列表需要花费大量时间。此外，我还有很多候选人要检查。

还有其他有效的方法吗？

原代码：

public static List findSimilarity(String word, List candidates) {
    List recommendations = new ArrayList();
    if (!word.equals("")) {
        for (String candidate : candidates) {
            if (!word.equals(candidate)) { //1. same token , lower/upper cases , ignore white spaces
                if (StringUtils.deleteWhitespace(word).equalsIgnoreCase(StringUtils.deleteWhitespace(candidate))) {
                    recommendations.add(candidate);
                }
                //2. same tokens diff order
                else if (candidate.split(" ").length == word.split("     ").length) {
                    String[] candidatearr = candidate.split(" ");
                    String[] wordarr = word.split(" ");
                    boolean status = true;
                    SortIgnoreCase icc = new SortIgnoreCase();
                    Arrays.sort(candidatearr, icc);
                    Arrays.sort(wordarr, icc);
                    for (int i = 0; i < candidatearr.length; i++) {
                        if (!(candidatearr[i] == null ? wordarr[i] == null : wordarr[i].equalsIgnoreCase(candidatearr[i])))
                            status = false;
                    }

                    if (status) {
                        recommendations.add(candidate);
                    }
                }
            }
        }
        //3. distance between words
        if (recommendations.size() == 0) {
            for (String candidate : candidates) {
                if (!word.equals(candidate)) {
                    String[] candidatearr = candidate.split(" ");
                    String[] wordarr = word.split(" ");
                    //check for acronym
                    if ((wordarr.length == 1 && candidatearr.length > 1) || (wordarr.length > 1 && candidatearr.length == 1)) {
                        String acronym = "";
                        if (wordarr.length > candidatearr.length) {
                            for (String tmp : wordarr) {
                                if (!tmp.equals("")) {
                                    acronym = acronym + tmp.substring(0, 1);
                                }
                            }

                            if (acronym.equalsIgnoreCase(candidatearr[0])) {
                                recommendations.add(candidate);
                            }
                        } else {
                            for (String tmp : candidatearr) {
                                if (!tmp.equals("")) {
                                    acronym = acronym + tmp.substring(0, 1);
                                }
                            }

                            if (acronym.equalsIgnoreCase(wordarr[0])) {
                                recommendations.add(candidate);
                            }
                        }
                    }
                }
            }
        }

        if (recommendations.size() == 0) {
            for (String candidate : candidates) {
                if (!word.equals(candidate)) {
                    int dist = 0;
                    String check = "";
                    if (word.length() > candidate.length()) {
                        check = candidate;
                    } else {
                        check = word;
                    }
                    if (check.length() <= 3) {
                        dist = 0;
                    } else if (check.length() > 3 && check.length() <= 5) {
                        dist = 1;
                    } else if (check.length() > 5) {
                        dist = 2;
                    }

                    if (StringUtils.getLevenshteinDistance(word, candidate) <= dist) {
                        //if(Levenshtein.distance(word,candidate) <= dist){
                        recommendations.add(candidate);
                    }
                }
            }
        }

        if (recommendations.size() == 0) {
            for (String candidate : candidates) {
                if (!word.equals(candidate)) {
                    String[] candidatearr = candidate.split(" ");
                    String[] wordarr = word.split(" ");

                    for (String cand : candidatearr) {
                        for (String wor : wordarr) {
                            if (cand.equals(wor) && cand.length() > 4) {
                                recommendations.add(candidate);

                            }
                        }
                    }
                }
            }//for
            if (recommendations.size() > 4) {
                recommendations.clear();
            }
        }

        //4. low priority - starts with
        if (recommendations.size() == 0) {
            for (String candidate : candidates) {
                if (!word.equals(candidate)) {
                    if (candidate.startsWith(word) || word.startsWith(candidate)) {
                        recommendations.add(candidate);
                    }
                }
            }
            if (recommendations.size() > 4) {
                recommendations.clear();
            }
        }

        //5. low priority - contain word
        if (recommendations.size() == 0) {
            for (String candidate : candidates) {
                if (!word.equals(candidate)) {
                    if (candidate.contains(word) || word.contains(candidate)) {
                        recommendations.add(candidate);
                    }
                }
            }
            if (recommendations.size() > 4) {
                recommendations.clear();
            }
        }
    }
    return recommendations;
}

谢谢， M.

Answer 1

您的问题是时间复杂度之一。 Collections.sort() 是一个 O(n log n) 操作，这是调用 compare 方法的次数。问题是 Levenshtein 是一个“昂贵”的计算。

您可以通过找到一种方法来提高排序性能，方法是为每个项目精确计算一次，使 Levenshtein 计算成为 O(n) 操作，然后对存储的计算距离进行排序。

我做了一个测试，使用各种列表大小排序随机整数列表，实际调用compare()的次数非常接近n log₂ n，所以对于一个列表大约 1000 个字符串，它会快 10 倍左右，因为 log₂(1000) 大约是 10。

您可以通过不排序来进一步提高性能，而只需让最小项指定相同的比较器。

另一个改进是避免distinct() 调用（相对昂贵），通过使用 Set（强制唯一性）来保存候选人。

如果可以的话，用已经训练和小写的值填充候选，这样你就可以避免每次运行都修剪和小写和小写。输入相同的内容，这样您就可以使用equals() 而不是较慢的equalsIgnoreCase()。

这是一种方法：

import static org.apache.commons.lang.StringUtils.getLevenshteinDistance;

String search; // your input
Set<String> candidates = new HashSet<>(); // populate this with lots of values
Map<String, Integer> cache = new ConcurrentHashMap<>();
String closest = candidates.parallelStream()
    .map(String::trim)
    .filter(s -> !s.equalsIgnoreCase(search))
    .min((a, b) -> Integer.compare(
      cache.computeIfAbsent(a, k -> getLevenshteinDistance(search, k)),
      cache.computeIfAbsent(b, k -> getLevenshteinDistance(search, k))))
    .get();

对于 1000 个随机候选者，此代码的执行时间约为 50 毫秒，对于 100 万个候选者，此代码的执行时间约为 1 秒。

Answer 2

已编辑

我将 Bohemian 给出的答案包装到您原始代码的上下文中，以便您更好地理解。

.map(term -> Arrays.stream(term.split(" ")).sorted().collect(Collectors.joining(" "))) 行将多词项拆分、排序并再次连接以消除相同词的排列。这是对“主色”和“主色”等术语的置换相等性挑战的答案。

但是，在这个问题的上下文中捕获任务的所有业务需求是没有意义的。通过这个答案，您已经获得了解决方案的概要。效率问题得到解决。您的管道中可能需要更多阶段，但这是另一回事。该方法的优势在于所有阶段都是独立的，因此您可以针对每个阶段独立提出问题并寻求帮助。

public static String findSimilarity(String word, List<String> candidatesList) {

    // Populating the set with distinct values of the input terms
    Set<String> candidates = candidatesList.stream()
            .map(String::toLowerCase)
            .map(term -> Arrays.stream(term.split(" ")).sorted().collect(Collectors.joining(" "))) // eliminates permutations
            .collect(Collectors.toSet());

    Map<String, Integer> cache = new ConcurrentHashMap<>();

    return candidates.parallelStream()
            .map(String::trim)
                    // add more mappers if needed
            .filter(s -> !s.equalsIgnoreCase(word))
                    // add more filters if needed
            .min((a, b) -> Integer.compare(
                    cache.computeIfAbsent(a, k -> getLevenshteinDistance(word, k)),
                    cache.computeIfAbsent(b, k -> getLevenshteinDistance(word, k))))
            .get(); // get the closest match
}