GATE-CS-2015 (Set 3) Question 54

This question is about designing a function to find a k-clique in an undirected graph. A k-clique is a set of k vertices where every vertex is connected to every other vertex in the set. The function signature is:

def find_k_clique(graph, k):

where graph is an adjacency matrix representation of the undirected graph and k is the size of the desired k-clique.

The basic idea behind the algorithm is to generate all possible combinations of k vertices in the graph and check if they form a k-clique. We can do this efficiently by using the Bron-Kerbosch algorithm, which uses a recursive backtracking algorithm to enumerate all possible maximal cliques in the graph.

The Bron-Kerbosch algorithm maintains three sets of vertices:

1. A set R of vertices that have been selected so far.
2. A set P of vertices that are candidates for selection (i.e., vertices that are adjacent to all vertices in R).
3. A set X of vertices that have been eliminated from consideration (i.e., vertices that are adjacent to some but not all vertices in R).

We start with R and X both empty and P containing all vertices in the graph. We then recursively explore all possible extensions of R by adding vertices from P. For each extension, we remove the non-candidates from P and add them to X. If R is a k-clique, we output it. Otherwise, we continue exploring all possible extensions.

The Python code for implementing the Bron-Kerbosch algorithm is as follows:

def bron_kerbosch(graph, r, p, x, k, cliques):
    if k == 0:
        cliques.append(r)
        return
    for v in p[:]:
        new_r = r + [v]
        new_p = [n for n in p if n in graph[v]]
        new_x = [n for n in x if n in graph[v]]
        bron_kerbosch(graph, new_r, new_p, new_x, k - 1, cliques)
        p.remove(v)
        x.append(v)

def find_k_clique(graph, k):
    cliques = []
    p = set(range(len(graph)))
    r = []
    x = []
    bron_kerbosch(graph, r, p, x, k, cliques)
    return cliques

To use this function, we simply pass in the adjacency matrix representation of the graph and the desired size of the k-clique. For example, we can find all 4-cliques in a graph G as follows:

G = [[0, 1, 1, 0, 0, 0],
     [1, 0, 1, 1, 0, 0],
     [1, 1, 0, 1, 1, 0],
     [0, 1, 1, 0, 1, 1],
     [0, 0, 1, 1, 0, 1],
     [0, 0, 0, 1, 1, 0]]

cliques = find_k_clique(G, 4)
print(cliques)

This will output the following list of 4-cliques:

[[1, 2, 3, 4], [2, 3, 4, 5]]

Note that this algorithm has exponential worst-case running time, so it may not be practical for large graphs. However, it is still a useful tool for small to medium-sized graphs, and can be combined with other algorithms to solve more complex problems.