Question

我正在尝试解决clique problem。我正在使用Bron Kerbosch Clique algorithm，它很好地用java编写，可以找到一个聪明的实现here。然而，由于clique硬度，它可能非常慢，

我想要做的是使用我知道它们已连接的一组初始顶点。然后调用该方法。对于我的生活，我不确定我在这里做错了什么，结果不是派系。

注意：评论代码来自原始代码（上面链接）。

public class BronKerboschCliqueFinder<V, E> {

    //~ Instance fields --------------------------------------------------------

private final UndirectedGraph<V, E> graph;
private Collection<Set<V>> cliques;

 //   public Collection<Set<V>> getAllMaximalCliques()
 public Collection<Set<V>> getAllMaximalCliqes(Set<String> initials){
{
    // TODO:  assert that graph is simple

    cliques = new ArrayList<Set<V>>();
    List<V> potential_clique = new ArrayList<V>();
    List<V> candidates = new ArrayList<V>();
    List<V> already_found = new ArrayList<V>();
   // candidates.addAll(graph.getVertices());  instead I do this:
    for(V v : graph.getVertices()){
        if(initial.contains(v)){
            potential_clique.add(v);
        }else{
            candidates.add(v);
        }
    }
    findCliques(potential_clique, candidates, already_found);
    return cliques;
}


private void findCliques(
    List<V> potential_clique,
    List<V> candidates,
    List<V> already_found)
{

    List<V> candidates_array = new ArrayList<V>(candidates);
    if (!end(candidates, already_found)) {
        // for each candidate_node in candidates do
        for (V candidate : candidates_array) {
            List<V> new_candidates = new ArrayList<V>();
            List<V> new_already_found = new ArrayList<V>();

            // move candidate node to potential_clique
            potential_clique.add(candidate);
            candidates.remove(candidate);

            // create new_candidates by removing nodes in candidates not
            // connected to candidate node
            for (V new_candidate : candidates) {
                if (graph.isNeighbor(candidate, new_candidate))
                {
                    new_candidates.add(new_candidate);
                } // of if
            } // of for

            // create new_already_found by removing nodes in already_found
            // not connected to candidate node
            for (V new_found : already_found) {
                if (graph.isNeighbor(candidate, new_found)) {
                    new_already_found.add(new_found);
                } // of if
            } // of for

            // if new_candidates and new_already_found are empty
            if (new_candidates.isEmpty() && new_already_found.isEmpty()) {
                // potential_clique is maximal_clique
                cliques.add(new HashSet<V>(potential_clique));
                return;
            } // of if
            else {
                // recursive call
                findCliques(
                    potential_clique,
                    new_candidates,
                    new_already_found);
            } // of else

            // move candidate_node from potential_clique to already_found;
            already_found.add(candidate);
            potential_clique.remove(candidate);
        } // of for
    } // of if
}

private boolean end(List<V> candidates, List<V> already_found)
{
    // if a node in already_found is connected to all nodes in candidates
    boolean end = false;
    int edgecounter;
    for (V found : already_found) {
        edgecounter = 0;
        for (V candidate : candidates) {
            if (graph.isNeighbor(found, candidate)) {
                edgecounter++;
            } // of if
        } // of for
        if (edgecounter == candidates.size()) {
            end = true;
        }
    } // of for
    return end;
}
}

所以简而言之，我唯一的变化是getAllMaximalCliques方法。我不太确定递归调用方法在这里是如何工作的。

如果有任何帮助或指示，我将不胜感激。

Answer 1

因此，如果我理解正确，那么您是否尝试使用已知为子集的部分解决方案来推送递归，以减少所需的递归步骤数量？

在那种情况下，我认为你误入歧途的地方就是引导候选人阵列。在进入递归函数的任何时候，候选数组都包含所有不在潜在集团中的图元素，但它们分别连接到潜在集团的所有成员。最后一位是您错过的位：您已使用剩余的所有图形元素为候选项启动了注释，这为其余的递归设置了无效状态。

所以试试这个：

public Collection<Set<V>> getAllMaximalCliques(Collection<V> initials) {
    // TODO: assert that graph is simple

    cliques = new ArrayList<>();
    List<V> potential_clique = new ArrayList<>();
    List<V> candidates = new ArrayList<>();
    List<V> already_found = new ArrayList<>();

    // candidates.addAll(graph.getVertices());

    for (V v : graph.getVertices()) {
        if (initials.contains(v)) {
            // add initial values to potential clique
            potential_clique.add(v);
        } else {
            // only add to candidates if they are a neighbour of all other initials
            boolean isCandidate = true;
            for (V i : initials) {
                if (!graph.isNeighbor(v, i)) {
                    isCandidate = false;
                    break;
                }
            }
            if (isCandidate) {
                candidates.add(v);
            }
        }
    }

    findCliques(potential_clique, candidates, already_found);
    return cliques;
}

例如，根据链接中的测试代码，此代码现在打印包含V3和V4的两个派系：

public void testFindBiggestV3V4()
{
    UndirectedGraph<String, String> g = new UndirectedSparseGraph<>();
    createGraph(g);

    BronKerboschCliqueFinder2<String, String> finder = new BronKerboschCliqueFinder<>(g);

    Collection<String> initials = new ArrayList<>();
    initials.add(V3);
    initials.add(V4);

    Collection<Set<String>> cliques = finder.getAllMaximalCliques(initials);
    for (Set<String> clique : cliques) {
        System.out.println(clique);
    }
}

打印：

[v1, v4, v3, v2]
[v5, v4, v3]

在另一点上，编写此代码的方式会创建大量临时数组。看起来乍一看（我可能在这里错了）顶点只能处于以下四种状态之一：潜在，候选，找到，忽略，所以将一个状态添加到顶点对象，使用单个全局集合（图形），并在整个过程中操纵每个顶点的状态是一种有趣的方法，而不是不断分配更多的数组。

不知道这会不会更快或更快，而找出的唯一方法就是写它并尝试它，但如果我需要加速它，我会看一下。

无论如何，希望这有帮助。

使用Clique的递归方法

1 个答案: