public BiCliqueGraph findBipartiteComplementAndVertexCoverComplement(HashSet<Integer> maximalCliqueK1, HashSet<Integer> maximalCliqueK2, Graph OrigGraph)
	{		
		//Take bipartite complement from two maximal cliques and arrange the graph with minimal memory
		int clique1Size = maximalCliqueK1.size();
		int clique2Size = maximalCliqueK2.size();

		System.out.println("Clique 1 : "+clique1Size);
		System.out.println("Clique 2 : "+clique2Size);

		//Remove the common nodes from maximal cliques
		ArrayList<Integer> commonNode = findCommonNodesFromMaximalCliques(new ArrayList<Integer>(maximalCliqueK1), new ArrayList<Integer>(maximalCliqueK2));
		

		int graphSize = clique1Size + clique2Size;
		System.out.println("Original graph size 1 : "+OrigGraph.size());

		Graph bipartiteGraph = new Graph(graphSize);
		System.out.println("New graph size  : "+graphSize);

		CustomizedArrayList leftIndexArray = new CustomizedArrayList(clique1Size+1);
		CustomizedArrayList rightIndexArray = new CustomizedArrayList(clique2Size+1);

		ArrayList<Integer> indexArrayList = new ArrayList<Integer>(); 
		int[] indexArray = new int[graphSize+1];


		int leftVertexIndex = 1;
		int rightVertexIndex = clique1Size + 1;
		for(int u : maximalCliqueK1)
		{
			System.out.println("U Value : "+u);
			for(int v : maximalCliqueK2)
			{
				System.out.println("V Value : "+v);

				if((!OrigGraph.isNeighbor(u, v)) && (u!=v))
				{
					System.out.println("No Edge U :"+u+"  V : "+v+"  Left "+leftVertexIndex+"  Right   "+rightVertexIndex);
					bipartiteGraph.addEdge(leftVertexIndex, rightVertexIndex);
					bipartiteGraph.addEdge(rightVertexIndex, leftVertexIndex);

					//Left index array doesnt have to be verified with contains method, because the u is iterated in the outer for loop. So it will be iterated only once
					leftIndexArray.add(leftVertexIndex, u);
					if(!rightIndexArray.contains(v))
					{
						rightIndexArray.add(rightVertexIndex, v);
						rightVertexIndex++;
					}
					//indexArray[leftVertexIndex] = u;
					//indexArray[rightVertexIndex] = v;
				}

			}
			leftVertexIndex++;
			//rightVertexIndex = clique1Size +1;
		}

		//Find the minimum vertex cover from the bipartite complement
		MinimumVertexCover minVertexCover  = new MinimumVertexCover();
		BiPartiteGraph vertexCover = minVertexCover.getMinimumVertexCover(bipartiteGraph, leftVertexIndex, rightVertexIndex);

		ArrayList<Integer> leftBiCliqueVertices = new ArrayList<Integer>();
		ArrayList<Integer> rightBiCliqueVertices = new ArrayList<Integer>();
		//Find vertex cover complement
		for(int u : vertexCover.leftVertices)
		{
			for(int v : vertexCover.rightVertices)
			{
				if(!bipartiteGraph.isNeighbor(u, v))
				{
					leftBiCliqueVertices.add(leftIndexArray.get(u));
					rightBiCliqueVertices.add(rightIndexArray.get(v));

				}
			}
		}

		System.out.println(vertexCover.leftVertices.size());
		System.out.println(vertexCover.rightVertices.size());
		//Validating biclique
		boolean isValidBiClique = GraphValidationUtil.isValidBiClique(bipartiteGraph, leftBiCliqueVertices, rightBiCliqueVertices);
		System.out.println("The BiClique is  : "+isValidBiClique);

		printBiGraph(bipartiteGraph, leftBiCliqueVertices, rightBiCliqueVertices);

		return new BiCliqueGraph(leftBiCliqueVertices, rightBiCliqueVertices);
	}