perf: add lightweight Monte Carlo simulation paths in InfluenceSpreadSimulator

The monteCarlo() method runs thousands of simulation trials, but
each trial previously created full SimulationResult objects with
per-round RoundSnapshot deep-copies (LinkedHashMap clone of entire
state per round) and InfectionEvent timeline lists. None of this
data is read by monteCarlo — it only needs getTotalInfected(),
getRoundCount(), and getFinalState().

Add LightweightResult class and three lightweight simulation methods
(simulateICLightweight, simulateLTLightweight, simulateSIRLightweight)
that skip snapshot/timeline creation entirely. For a 1000-node graph
with 10 rounds and 10,000 trials, this eliminates ~100K unnecessary
Map deep-copies and ~100K ArrayList allocations.

The public simulation APIs (simulateIC, simulateLT, simulateSIR) are
unchanged — only the internal Monte Carlo hot path uses the fast path.

Author: sauravbhattacharya001

Gvisual/src/gvisual/InfluenceSpreadSimulator.java

@@ -389,22 +389,25 @@ public MonteCarloResult monteCarlo(Collection<String> seeds,
         Map<String, Integer> infectionFrequency = new LinkedHashMap<>();
 
         for (int i = 0; i < numTrials; i++) {
-            SimulationResult result;
+            // Use lightweight simulation (no snapshots/timeline) to avoid
+            // O(rounds × V) deep-copy overhead per trial. Monte Carlo only
+            // needs final state + round count, not per-round snapshots.
+            LightweightResult lr;
             switch (model) {
                 case INDEPENDENT_CASCADE:
-                    result = simulateIC(seeds, probability, maxRounds); break;
+                    lr = simulateICLightweight(seeds, probability, maxRounds); break;
                 case LINEAR_THRESHOLD:
-                    result = simulateLT(seeds, maxRounds); break;
+                    lr = simulateLTLightweight(seeds, maxRounds); break;
                 case SIR:
-                    result = simulateSIR(seeds, probability, recoveryRate, maxRounds); break;
+                    lr = simulateSIRLightweight(seeds, probability, recoveryRate, maxRounds); break;
                 default:
                     throw new IllegalArgumentException("Unknown model: " + model);
             }
 
-            spreads.add(result.getTotalInfected());
-            durations.add(result.getRoundCount());
+            spreads.add(lr.totalInfected);
+            durations.add(lr.rounds);
 
-            for (Map.Entry<String, NodeState> entry : result.getFinalState().entrySet()) {
+            for (Map.Entry<String, NodeState> entry : lr.finalState.entrySet()) {
                 if (entry.getValue() == NodeState.INFECTED ||
                     entry.getValue() == NodeState.RECOVERED) {
                     infectionFrequency.merge(entry.getKey(), 1, Integer::sum);
@@ -509,6 +512,124 @@ public VaccinationStrategy findVaccinationTargets(int k) {
         return new VaccinationStrategy(targets, totalEdgesBlocked, coverageRatio);
     }
 
+    // ─── Lightweight simulation (Monte Carlo fast path) ───────────
+
+    /**
+     * Minimal result for Monte Carlo: final state + round count only.
+     * Avoids the per-round LinkedHashMap deep-copies and InfectionEvent
+     * timeline that {@link SimulationResult} carries.
+     */
+    private static class LightweightResult {
+        final Map<String, NodeState> finalState;
+        final int rounds;
+        final int totalInfected;
+
+        LightweightResult(Map<String, NodeState> finalState, int rounds) {
+            this.finalState = finalState;
+            this.rounds = rounds;
+            int cnt = 0;
+            for (NodeState s : finalState.values())
+                if (s == NodeState.INFECTED || s == NodeState.RECOVERED) cnt++;
+            this.totalInfected = cnt;
+        }
+    }
+
+    private LightweightResult simulateICLightweight(Collection<String> seeds,
+                                                     double probability, int maxRounds) {
+        Map<String, NodeState> state = initState(seeds);
+        Set<String> newlyInfected = new LinkedHashSet<>();
+        for (String seed : seeds)
+            if (graph.containsVertex(seed)) newlyInfected.add(seed);
+        int round = 0;
+
+        while (!newlyInfected.isEmpty()) {
+            round++;
+            if (maxRounds > 0 && round > maxRounds) break;
+            Set<String> nextInfected = new LinkedHashSet<>();
+            for (String node : newlyInfected) {
+                for (String neighbor : getNeighbors(node)) {
+                    if (state.get(neighbor) == NodeState.SUSCEPTIBLE) {
+                        double edgeProb = getEdgeProbability(node, neighbor, probability);
+                        if (random.nextDouble() < edgeProb) {
+                            state.put(neighbor, NodeState.INFECTED);
+                            nextInfected.add(neighbor);
+                        }
+                    }
+                }
+            }
+            for (String node : newlyInfected) state.put(node, NodeState.RECOVERED);
+            newlyInfected = nextInfected;
+        }
+        return new LightweightResult(state, round);
+    }
+
+    private LightweightResult simulateLTLightweight(Collection<String> seeds, int maxRounds) {
+        Map<String, NodeState> state = initState(seeds);
+        Map<String, Double> thresholds = new HashMap<>();
+        for (String node : graph.getVertices()) thresholds.put(node, random.nextDouble());
+
+        int round = 0;
+        boolean changed = true;
+        while (changed) {
+            round++;
+            if (maxRounds > 0 && round > maxRounds) break;
+            changed = false;
+            List<String> toActivate = new ArrayList<>();
+            for (String node : graph.getVertices()) {
+                if (state.get(node) != NodeState.SUSCEPTIBLE) continue;
+                Collection<String> influencers = getPredecessors(node);
+                if (influencers.isEmpty()) continue;
+                int active = 0;
+                for (String nb : influencers)
+                    if (state.get(nb) == NodeState.INFECTED || state.get(nb) == NodeState.RECOVERED)
+                        active++;
+                if ((double) active / influencers.size() >= thresholds.get(node))
+                    toActivate.add(node);
+            }
+            for (String node : toActivate) {
+                state.put(node, NodeState.INFECTED);
+                changed = true;
+            }
+        }
+        return new LightweightResult(state, round);
+    }
+
+    private LightweightResult simulateSIRLightweight(Collection<String> seeds,
+                                                      double infectionRate,
+                                                      double recoveryRate, int maxRounds) {
+        Map<String, NodeState> state = initState(seeds);
+        Set<String> currentlyInfected = new LinkedHashSet<>();
+        for (String seed : seeds)
+            if (graph.containsVertex(seed)) currentlyInfected.add(seed);
+        int round = 0;
+
+        while (!currentlyInfected.isEmpty()) {
+            round++;
+            if (maxRounds > 0 && round > maxRounds) break;
+            Set<String> toInfect = new LinkedHashSet<>();
+            Set<String> toRecover = new LinkedHashSet<>();
+            for (String node : currentlyInfected) {
+                for (String neighbor : getNeighbors(node)) {
+                    if (state.get(neighbor) == NodeState.SUSCEPTIBLE && !toInfect.contains(neighbor)) {
+                        double edgeProb = getEdgeProbability(node, neighbor, infectionRate);
+                        if (random.nextDouble() < edgeProb) toInfect.add(neighbor);
+                    }
+                }
+            }
+            for (String node : currentlyInfected)
+                if (random.nextDouble() < recoveryRate) toRecover.add(node);
+            for (String node : toInfect) {
+                state.put(node, NodeState.INFECTED);
+                currentlyInfected.add(node);
+            }
+            for (String node : toRecover) {
+                state.put(node, NodeState.RECOVERED);
+                currentlyInfected.remove(node);
+            }
+        }
+        return new LightweightResult(state, round);
+    }
+
     // ─── Helpers ────────────────────────────────────────────────
 
     private void validateSeeds(Collection<String> seeds) {