# Java Program to Find the Largest Clique in a Planar Graph

• Last Updated : 03 Sep, 2021

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 > adjacency_list,``         ``Vector 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 > adjacency_list,``          ``Vector 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 tmp_color = ``new` `Vector();` `        ``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 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 > adjacency_list,``               ``Vector 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 tmp_color``                    ``= ``new` `Vector();` `                ``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 adj_list,``                                 ``Vector 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 > adjacency_matrix``            ``= ``new` `Vector >(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 adj = ``new` `Vector(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 > adjacency_list``            ``= ``new` `Vector >();` `        ``// Nested for loops for creating the adjacency list``        ``// of graph given``        ``for` `(``int` `i = ``0``; i < n; ++i) {``            ``Vector adj_list``                ``= ``new` `Vector();` `            ``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 > set_found``            ``= ``new` `Vector >();` `        ``// 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 color = ``new` `Vector(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 color``                    ``= ``new` `Vector(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.

My Personal Notes arrow_drop_up