perf: cache neighbor sets in CliqueAnalyzer Bron-Kerbosch

getNeighbors() was creating a new LinkedHashSet copy of each
vertex's adjacency list on every call.  During Bron-Kerbosch
recursion and pivot selection, this is called O(V * recursion
depth) times — for dense graphs with many cliques, the
temporary allocation pressure dominates runtime.

Fix: build a HashMap<String, Set<String>> neighbor cache once
at the start of compute(), before entering recursion.  The
recursive bronKerbosch(), choosePivot(), and countIntersection()
methods now read from this cache with O(1) lookups instead of
allocating.  Defensive fallback retained for vertices not in
cache (should never trigger after compute() initialisation).

Author: sauravbhattacharya001

Gvisual/src/gvisual/CliqueAnalyzer.java

@@ -31,6 +31,7 @@
 public class CliqueAnalyzer {
 
     private final Graph<String, edge> graph;
+    private Map<String, Set<String>> neighborCache;
     private List<Set<String>> cliques;
     private boolean computed;
 
@@ -45,6 +46,7 @@ public CliqueAnalyzer(Graph<String, edge> graph) {
             throw new IllegalArgumentException("Graph must not be null");
         }
         this.graph = graph;
+        this.neighborCache = new HashMap<String, Set<String>>();
         this.cliques = new ArrayList<Set<String>>();
         this.computed = false;
     }
@@ -68,6 +70,20 @@ public CliqueAnalyzer compute() {
             return this;
         }
 
+        // Pre-build neighbor sets once so the recursive hot-path never
+        // allocates temporary collections.  Without this cache each
+        // getNeighbors() call created a new LinkedHashSet — O(V^2)
+        // allocations in the worst case during pivot selection alone.
+        neighborCache = new HashMap<String, Set<String>>(vertices.size() * 2);
+        for (String v : vertices) {
+            Collection<String> neighbors = graph.getNeighbors(v);
+            if (neighbors == null) {
+                neighborCache.put(v, new LinkedHashSet<String>());
+            } else {
+                neighborCache.put(v, new LinkedHashSet<String>(neighbors));
+            }
+        }
+
         // For isolated vertices (no neighbors), each is a trivial maximal clique
         Set<String> P = new LinkedHashSet<String>(vertices);
         Set<String> R = new LinkedHashSet<String>();
@@ -166,6 +182,10 @@ private int countIntersection(Set<String> a, Set<String> b) {
     }
 
     private Set<String> getNeighbors(String vertex) {
+        Set<String> cached = neighborCache.get(vertex);
+        if (cached != null) return cached;
+        // Fallback for vertices not in the cache (should not happen
+        // after compute() builds the cache, but defensive).
         Collection<String> neighbors = graph.getNeighbors(vertex);
         if (neighbors == null) return new LinkedHashSet<String>();
         return new LinkedHashSet<String>(neighbors);