perf: track infected nodes in SIR simulation instead of scanning all vertices

The SIR simulateSIR() method previously iterated all V vertices twice per
round: once to find infected nodes for spreading, and once for recovery
checks, plus a third pass to check if any infected remain.

Replace with an explicit currentlyInfected set that is maintained
incrementally. This reduces per-round cost from O(V) to O(|infected|)
for the recovery check and termination test, which is significant for
large sparse graphs where only a small fraction of nodes are infected
at any given time. The infection spreading loop also benefits since it
now only iterates currently infected nodes.

This is especially impactful during Monte Carlo simulations where
simulateSIR is called thousands of times.

Author: sauravbhattacharya001

Gvisual/src/gvisual/InfluenceSpreadSimulator.java

@@ -315,20 +315,27 @@ public SimulationResult simulateSIR(Collection<String> seeds,
         List<RoundSnapshot> snapshots = new ArrayList<>();
         List<InfectionEvent> timeline = new ArrayList<>();
 
+        // Track currently infected nodes explicitly to avoid iterating
+        // all V vertices each round just to find the infected subset.
+        // For large graphs with low infection rates, this reduces per-round
+        // cost from O(V) to O(|infected| * avg_degree).
+        Set<String> currentlyInfected = new LinkedHashSet<>();
+        for (String seed : seeds) {
+            if (graph.containsVertex(seed)) currentlyInfected.add(seed);
+        }
+
         int round = 0;
         snapshots.add(createSnapshot(round, state));
 
-        boolean hasInfected = true;
-        while (hasInfected) {
+        while (!currentlyInfected.isEmpty()) {
             round++;
             if (maxRounds > 0 && round > maxRounds) break;
 
             Set<String> toRecover = new LinkedHashSet<>();
             Set<String> toInfect = new LinkedHashSet<>();
             Map<String, String> infectedBy = new LinkedHashMap<>();
 
-            for (String node : graph.getVertices()) {
-                if (state.get(node) != NodeState.INFECTED) continue;
+            for (String node : currentlyInfected) {
                 for (String neighbor : getNeighbors(node)) {
                     if (state.get(neighbor) == NodeState.SUSCEPTIBLE &&
                         !toInfect.contains(neighbor)) {
@@ -341,31 +348,26 @@ public SimulationResult simulateSIR(Collection<String> seeds,
                 }
             }
 
-            for (String node : graph.getVertices()) {
-                if (state.get(node) == NodeState.INFECTED) {
-                    if (random.nextDouble() < recoveryRate) {
-                        toRecover.add(node);
-                    }
+            for (String node : currentlyInfected) {
+                if (random.nextDouble() < recoveryRate) {
+                    toRecover.add(node);
                 }
             }
 
             for (String node : toInfect) {
                 state.put(node, NodeState.INFECTED);
+                currentlyInfected.add(node);
                 String source = infectedBy.get(node);
                 if (source != null) {
                     timeline.add(new InfectionEvent(source, node, round));
                 }
             }
             for (String node : toRecover) {
                 state.put(node, NodeState.RECOVERED);
+                currentlyInfected.remove(node);
             }
 
             snapshots.add(createSnapshot(round, state));
-
-            hasInfected = false;
-            for (NodeState s : state.values()) {
-                if (s == NodeState.INFECTED) { hasInfected = true; break; }
-            }
         }
 
         return new SimulationResult(Model.SIR, seeds,