⚡️ Speed up function graph_traversal by 1,193%

The optimized code achieves a ~12x speedup by replacing a list-based visited tracking mechanism with a set-based approach, addressing the core performance bottleneck in graph traversal.

**Key Optimization Applied:**
- **Separated concerns**: Uses a `set()` for O(1) membership checking (`visited`) and a separate `list` for maintaining traversal order (`result`)
- **Fixed graph.get() default**: Changed from `graph.get(n, [])` to `graph.get(n, {})` to match the expected dict type

**Why This Creates Massive Speedup:**
The original code's `if n in visited` operation on a list has O(n) time complexity - it must scan through the entire list linearly. As the graph grows, each membership check becomes progressively slower. The optimized version uses `if n in visited` on a set, which is O(1) average case due to hash table lookups.

**Performance Impact by Graph Size:**
- **Small graphs (1-10 nodes)**: Minimal improvement or slight regression (~5-20% slower) due to set overhead
- **Medium graphs (30-200 nodes)**: Significant gains (155-331% faster) as O(n) vs O(1) difference becomes apparent  
- **Large graphs (500-1000 nodes)**: Dramatic speedups (844-2362% faster) where the quadratic behavior of list membership checking becomes the dominant cost

**Best Use Cases:**
The optimization excels for:
- Large star graphs where many nodes are visited quickly
- Complete or dense graphs with high connectivity
- Long traversal paths where membership checks accumulate
- Any scenario where the visited set grows beyond ~20-30 nodes

The annotation test results clearly show this pattern - small test cases are slightly slower due to set initialization overhead, while large-scale tests show exponential performance gains as the visited collection grows.

Author: codeflash-ai[bot]

src/dsa/various.py

@@ -48,17 +48,19 @@ def matrix_sum(matrix: list[list[int]]) -> list[int]:
 
 
 def graph_traversal(graph: dict[int, dict[int]], node: int) -> dict[int]:
-    visited = []
+    visited = set()
+    result = []
 
     def dfs(n: int) -> None:
         if n in visited:
             return
-        visited.append(n)
-        for neighbor in graph.get(n, []):
+        visited.add(n)
+        result.append(n)
+        for neighbor in graph.get(n, {}):
             dfs(neighbor)
 
     dfs(node)
-    return visited
+    return result
 
 
 def regex_match(strings: list[str], pattern: str) -> list[str]: