Java Program to Find the Largest Clique in a Planar Graph

Independent set of Graph as a pre-requisite is the set of vertices where no two are adjacent to each other. It is just opposite in definition to clique, Hence knowledge about the complements of a graph is necessary in order to go further. Basically, the idea of a planar graph is not of utmost importance but can be referred. Hence, we will be using the idea of all these three to solve the Question mentioned.

We are required to find the largest Clique in the given Planar Graph. The clique of any planar graph is the subset of vertices such that any two vertexes in that subset are adjacent to each other i.e. the set of vertices form a complete graph and this complete graph is a subgraph of a given planar graph. In other words, Maximal Clique is the maximum subset of vertices such that they form a complete subgraph in the given graph and no more vertices can be added to that subset. Now if we are familiar with the idea of independent sets then we can found a foggy relationship between the two concepts: Clique and Independent-set. 

Hence, the relationship and differences go hand in hand as discussed below:

• A Clique is a set of vertices of an undirected or planar graph such that every two distinct vertices in the clique are adjacent.
• An Independent set is a set of vertices such that no two are adjacent to each other.
• The idea of maximal is the same for both sets.

The definition of both Clique and independent sets of a graph directly indicates that there is some complementary relationship between them.

Suppose if we complement our given graph, then according to the definition of the maximal independent set, it will be the largest set of those vertices which are not adjacent to each other in the real graph (since we are finding the independent set in the complement graph). Hence, the maximal independent set of the complement of the given graph is nothing but the maximal Clique in the given graph.

Concept:

So the largest Clique of a given graph can be considered as the largest Independent set in the complement graph of the given graph. Since we are having many ways to find the largest independent sets of a given planar graph (although they are NP-hard problems) we can use any of them to find the clique. We just have to make a small change in the given algorithms in that we have to input the complement of the input graph.

Implementation: graph as shown as below as follows:

• Now we are going to find the Largest clique in the above-given graph. (which is the subgraph made up of green edges)
• The below given is the implementation of above idea of finding the independent set of a graph’s complement which is indirectly the Clique of that Graph.

Go through if you do not know the idea in order to find the Independent set of graph using different methods 

Example

Java

// Java Program to Find Independent Sets in a Graph
// By Graph Coloring

// Importing input output classes
import java.io.*;
// Importing utility classes from java.util package
import java.util.*;

// Class 1
// Helper class
class GFGUTIL {

    // Method 1
    // To label maximum vertices with 0
    // that can be included in the set
    public static void
    Util(Vector<Vector<Integer> > adjacency_list,
         Vector<Integer> color)
    {
        int a = 0;

        // Condition check
        while (a != -1) {
            a = remove_all(adjacency_list, color);

            if (a != -1)
                color.set(a, 0);
        }
    }

    // Method 2
    // Tries whether it is possible to remove
    // any adjacent vertex of any removed vertex
    public static void
    Util2(Vector<Vector<Integer> > adjacency_list,
          Vector<Integer> color, int j)
    {

        int cnt = 0;

        // Implementation
        // It removes the colored node i.e. uncolor it
        // so that some of the adjacent vertices which can
        // provide more elements to
        //  set are colored who were hindered due to the
        //  previous node.

        Vector<Integer> tmp_color = new Vector<Integer>();

        for (int g = 0; g < color.size(); ++g)
            tmp_color.add(color.get(g));

        for (int i = 0; i < color.size(); ++i) {

            if (tmp_color.get(i) == 1) {

                int sum = 0;
                int idx = -1;

                for (int g = 0;
                     g < adjacency_list.get(i).size(); ++g)

                    if (tmp_color.get(
                            adjacency_list.get(i).get(g))
                        == 0) {

                        idx = g;
                        sum++;
                    }

                if (sum == 1
                    && color.get(
                           adjacency_list.get(i).get(idx))
                           == 0) {

                    tmp_color.set(
                        adjacency_list.get(i).get(idx), 1);
                    tmp_color.set(i, 0);
                    Util(adjacency_list, tmp_color);
                    ++cnt;
                }

                if (cnt > j)
                    break;
            }
        }

        for (int g = 0; g < color.size(); ++g)
            color.set(g, tmp_color.get(g));
    }

    // Method 3
    // Returning the number of vertices
    // that can't be included in the set
    public static int Util3(Vector<Integer> color)
    {

        int cnt = 0;

        // Checking the condition when the vertices cannot
        // be included.
        for (int i = 0; i < color.size(); i++)

            if (color.get(i) == 1)
                ++cnt;

        return cnt;
    }

    // Method 4
    // This method return all the elements which can be
    // removed.
    public static int
    remove_all(Vector<Vector<Integer> > adjacency_list,
               Vector<Integer> color)
    {

        int a = -1, max = -1;

        for (int i = 0; i < color.size(); ++i) {
            if (color.get(i) == 1
                && can_remove(adjacency_list.get(i), color)
                       == 1) {

                Vector<Integer> tmp_color
                    = new Vector<Integer>();

                for (int j = 0; j < color.size(); ++j)
                    tmp_color.add(color.get(j));
                tmp_color.set(i, 0);

                int sum = 0;

                for (int j = 0; j < tmp_color.size(); ++j)

                    if (tmp_color.get(j) == 1
                        && can_remove(adjacency_list.get(j),
                                      tmp_color)
                               == 1)
                        ++sum;

                if (sum > max) {
                    max = sum;
                    a = i;
                }
            }
        }

        // Index of the vertex
        return a;
    }

    // Method 5
    // To check whether a vertex can be removed or not
    public static int can_remove(Vector<Integer> adj_list,
                                 Vector<Integer> color)
    {

        int check = 1;
        // condition checking for removal
        for (int i = 0; i < adj_list.size(); ++i)

            // cannot be removed if this condition happens
            if (color.get(adj_list.get(i)) == 0)
                check = 0;

        return check;
    }
}

// Class 2
// Main class
public class GFG {

    // Main driver method
    public static void main(String[] args) throws Exception
    {
        // Graph input alongside forming it's adjacency List

        // Display message for better readability
        System.out.println(
            "The number of vertices in the graph is taken as 5");

        // Custom input is taken here
        int n = 5;

        // Creating a vector object for adjacency matrix.
        Vector<Vector<Integer> > adjacency_matrix
            = new Vector<Vector<Integer> >(n, (n));

        // Input matrix is
        // 01111
        // 10111
        // 11010
        // 11100
        // 11000

        // Complement graph's matrix of the given input
        // graph 00000 00000 00001 00001 00110

        // Nested for loops for iterations
        // creating the adjacency matrix of the input graph

        // As shown above
        for (int i = 0; i < n; ++i) {
            Vector<Integer> adj = new Vector<Integer>(n);

            for (int j = 0; j < n; ++j)

                if ((i == 2 && j == 4) || (i == 3 && j == 4)
                    || (i == 4 && j == 2)
                    || (i == 4 && j == 3))
                    adj.add(1);
                else

                    adj.add(0);
            adjacency_matrix.add(adj);
        }

        // Creating a vector object for adjacency list
        Vector<Vector<Integer> > adjacency_list
            = new Vector<Vector<Integer> >();

        // Nested for loops for creating the adjacency list
        // of graph given
        for (int i = 0; i < n; ++i) {
            Vector<Integer> adj_list
                = new Vector<Integer>();

            for (int j = 0; j < n; ++j) {
                if (adjacency_matrix.get(i).get(j) == 1)
                    adj_list.add(j);
            }

            adjacency_list.add(adj_list);
        }

        // Display message only for
        // taking the minimum size of the set required.
        System.out.println(
            "The maximal independent set's size to be find is 4");

        // Declaring and initializing variable with
        // least size of the set required
        // can be set to full size too.
        int x = 4;

        // Complement of the size
        int y = n - x;
        int found = 0;
        c // variable to check if answer is found
            int size
            = 0;
        int min = n + 1;

        // Creating a set found vector to
        // store all the possible set
        Vector<Vector<Integer> > set_found
            = new Vector<Vector<Integer> >();

        // Display message
        System.out.println("Searching for the set");

        for (int i = 0; i < n; ++i) {

            // If set is found
            if (found == 1)

                // Hault the further execution of Program
                break;

            // graph coloring method is used.
            // Color vector to have the state of all the
            // vertices initially
            Vector<Integer> color = new Vector<Integer>(n);

            for (int j = 0; j < n; ++j)
                color.add(1);

            // Starting by putting the ith node in set
            color.set(i, 0);

            // Then finding all the nodes to be pushed
            GFGUTIL.Util(adjacency_list, color);

            // Finding the number of those which cannot be
            // pushed in set
            size = GFGUTIL.Util3(color);
            if (size < min)
                min = size;

            // If the number of elements in set
            //  are more or equal
            if (size <= y) {

                // Print and display the size
                System.out.println(
                    "Independent set of size " + (n - size)
                    + "found");

                for (int j = 0; j < n; ++j)

                    if (color.get(j) == 0)

                        System.out.print(j + 1 + " ");
                System.out.println();
                set_found.add(color);

                // Set flag to 1
                found = 1;

                // Hault the further execution of Program
                break;
            }

            // If sufficient nodes are not found then
            // we call util2 function

            for (int j = 0; j < x; ++j)
                GFGUTIL.Util2(adjacency_list, color, j);

            // Getting the possible size from util2
            size = GFGUTIL.Util3(color);

            if (size < min)
                min = size;

            // Printing what's found of which size and
            // contents
            System.out.println("Independent set of size "
                               + (n - size) + "found");

            for (int j = 0; j < n; ++j)

                if (color.get(j) == 0)

                    System.out.print(j + 1 + " ");
            System.out.println();
            set_found.add(color);

            // If found then set the flag to 1 and hault
            if (size <= y) {
                found = 1;

                break;
            }
        }

        int r = set_found.size();

        // Now searching pairwise and
        // repeating same procedure as above discussed
        // But using the idea discussed above in the
        // article.
        for (int a = 0; a < r; ++a) {

            if (found == 1)
                break;

            for (int b = a + 1; b < r; ++b) {

                if (found == 1)
                    break;

                Vector<Integer> color
                    = new Vector<Integer>(n);

                for (int j = 0; j < n; ++j)
                    color.add(1);

                for (int c = 0; c < n; ++c)
                    if (set_found.get(a).get(c) == 0
                        && set_found.get(b).get(c) == 0)
                        color.set(c, 0);

                GFGUTIL.Util(adjacency_list, color);
                size = GFGUTIL.Util3(color);

                if (size < min)
                    min = size;
                if (size <= y) {

                    System.out.println(
                        "Independent set of size"
                        + (n - size));

                    for (int j = 0; j < n; ++j)

                        if (color.get(j) == 0)

                            System.out.print(j + 1 + " ");

                    System.out.println();
                    found = 1;
                    break;
                }

                for (int j = 0; j < y; ++j)
                    GFGUTIL.Util2(adjacency_list, color, j);
                size = GFGUTIL.Util3(color);
                if (size < min)
                    min = size;

                System.out.println(
                    "Independent set of size " + (n - size)
                    + "found");

                for (int j = 0; j < n; ++j)

                    if (color.get(j) == 0)
                        System.out.print(j + 1 + " ");

                System.out.println();

                if (size <= y) {
                    found = 1;
                    break;
                }
            }
        }

        // If it is found
        if (found == 1)

            // Display command
            System.out.println(
                "Found set of " + (n - size)
                + " size whose elements are displayed above as a clique for the input graph");

        // Not found
        else

            // Display command
            System.out.println(
                "Found set of " + (n - size)
                + " size whose elements are displayed above as a clique for the input graph");
    }
}

Output

The number of vertices in the graph is taken as 5
The maximal independent set's size to be find is 4
Searching for the set
Independent set of size 4found
1 2 3 4 
Found set of 4 size whose elements are displayed above as a clique for the input graph

Output explanation:

As we can see the output tells that the number of vertices taken are 5 and after finding the independent set of size 4 it return the set of vertices which together forms the independent set in the complement graph and since we had discussed that independent set of complements are clique in original graphs hence these sets are the clique in the original graph. 

Note: If we will mention the full size of graph (i.e. 5 in above eg), Then the output is shown below:

The number of vertices in the graph is taken as 5
The maximal independent set's size to be find is 5
Searching for the set
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Independent set of size 4found
1 2 3 4 
Found set of 4 size whose elements are displayed above as a clique for the input graph

Output explanation:

In order to find the maximal clique set just mention the original size of the graph (i.e. 5 here). If any independent set of such size is found then it is returned to the output else the nearest maximum one is returned. Hence, we can always find the maximal clique set of graphs with this idea. Hence, we can see that the above idea worked, and we are able to find the maximal clique of the given graph.