⚡️ Speed up function find_last_node by 16,667%

[codeflash-ai]

📄 16,667% (166.67x) speedup for find_last_node in src/algorithms/graph.py

⏱️ Runtime : 98.3 milliseconds → 586 microseconds (best of 166 runs)

📝 Explanation and details

The optimized code achieves a 167x speedup (from 98.3ms to 586μs) by eliminating a critical algorithmic bottleneck.

What Changed:
The original implementation uses a nested loop structure: for each node, it checks all(e["source"] != n["id"] for e in edges), which iterates through every edge. This creates O(nodes × edges) time complexity.

The optimized version precomputes a set of all source IDs with sources = {e["source"] for e in edges}, then checks membership with n["id"] not in sources. Set membership is O(1) on average, reducing overall complexity to O(nodes + edges).

Why This Is Faster:
In Python, the all() function with a generator expression forces iteration over the entire edges list for each node. With many edges, this becomes extremely expensive. The line profiler shows the original code spending 770ms in that single line across 59 calls.

The optimized approach builds the set once (561μs) then performs fast lookups (346μs total for all nodes). Set construction is O(edges) and lookups are O(1), making the total O(nodes + edges) instead of O(nodes × edges).

Performance Characteristics:

• Large graphs with many edges: The optimization shines here. Test cases like test_large_linear_chain (1000 nodes, 999 edges) show 327x speedup (18.5ms → 56.4μs), and test_large_complete_graph (100 nodes, 9900 edges) shows 88x speedup (17.3ms → 193μs).
• Small graphs: Even small graphs benefit significantly (60-100% faster for 2-3 node graphs) because set construction overhead is minimal with few edges.
• Sparse graphs: When there are many nodes but few edges (like test_many_nodes_few_edges), the optimization still helps (139% faster) since building a small set is cheap and eliminates redundant edge traversals.

The optimization is universally beneficial across all test cases, with particularly dramatic improvements when the edge count is high relative to nodes.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 59 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from src.algorithms.graph import find_last_node

# unit tests

# 1. BASIC TEST CASES


def test_single_node_no_edges():
    # Only one node, no edges: should return the node itself
    nodes = [{"id": 1, "name": "A"}]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.33μs -> 1.00μs (33.4% faster)


def test_two_nodes_one_edge():
    # Two nodes, one edge from node 1 to node 2: node 2 is last
    nodes = [{"id": 1}, {"id": 2}]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.83μs -> 1.12μs (63.0% faster)


def test_three_nodes_linear_chain():
    # 1 -> 2 -> 3, so node 3 is the last node
    nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
    edges = [{"source": 1, "target": 2}, {"source": 2, "target": 3}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 2.21μs -> 1.25μs (76.6% faster)


def test_multiple_possible_last_nodes():
    # 1 -> 2, 3 is disconnected, so both 2 and 3 have no outgoing edges
    nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.88μs -> 1.12μs (66.7% faster)


def test_no_nodes():
    # No nodes at all: should return None
    nodes = []
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 834ns -> 833ns (0.120% faster)


# 2. EDGE TEST CASES


def test_all_nodes_have_outgoing_edges():
    # Every node has at least one outgoing edge: should return None
    nodes = [{"id": 1}, {"id": 2}]
    edges = [{"source": 1, "target": 2}, {"source": 2, "target": 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.96μs -> 1.21μs (62.1% faster)


def test_node_with_self_loop():
    # Node with a self-loop is not a last node
    nodes = [{"id": 1}, {"id": 2}]
    edges = [{"source": 1, "target": 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.83μs -> 1.08μs (69.1% faster)


def test_disconnected_nodes():
    # Some nodes are not connected by any edge
    nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.25μs -> 1.00μs (25.0% faster)


def test_multiple_edges_from_one_node():
    # Node 1 has two outgoing edges, nodes 2 and 3 have none
    nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
    edges = [{"source": 1, "target": 2}, {"source": 1, "target": 3}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.92μs -> 1.21μs (58.6% faster)


def test_edges_with_nonexistent_nodes():
    # Edge refers to nodes not in the node list; should ignore them
    nodes = [{"id": 1}, {"id": 2}]
    edges = [{"source": 1, "target": 3}, {"source": 3, "target": 1}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.92μs -> 1.17μs (64.2% faster)


def test_nodes_with_extra_fields():
    # Nodes have extra fields, should not affect result
    nodes = [{"id": 1, "label": "A"}, {"id": 2, "label": "B"}]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.83μs -> 1.04μs (75.9% faster)


def test_edges_with_extra_fields():
    # Edges have extra fields, should not affect result
    nodes = [{"id": 1}, {"id": 2}]
    edges = [{"source": 1, "target": 2, "weight": 5}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.83μs -> 1.12μs (63.0% faster)


def test_duplicate_nodes():
    # Duplicate nodes in the list: should return the first last node found
    nodes = [{"id": 1}, {"id": 2}, {"id": 2}]
    edges = [{"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.83μs -> 1.08μs (69.1% faster)


def test_duplicate_edges():
    # Duplicate edges should not affect result
    nodes = [{"id": 1}, {"id": 2}]
    edges = [{"source": 1, "target": 2}, {"source": 1, "target": 2}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.88μs -> 1.17μs (60.7% faster)


def test_non_integer_node_ids():
    # Node ids are strings
    nodes = [{"id": "A"}, {"id": "B"}]
    edges = [{"source": "A", "target": "B"}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.92μs -> 1.17μs (64.4% faster)


def test_empty_edges_nonempty_nodes():
    # All nodes have no outgoing edges
    nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.29μs -> 1.00μs (29.2% faster)


def test_edge_case_large_id_values():
    # Node ids are very large integers
    nodes = [{"id": 999999999}, {"id": 888888888}]
    edges = [{"source": 999999999, "target": 888888888}]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.96μs -> 1.21μs (62.1% faster)


# 3. LARGE SCALE TEST CASES


def test_large_linear_chain():
    # 1000 nodes in a chain: 1 -> 2 -> ... -> 1000
    N = 1000
    nodes = [{"id": i} for i in range(1, N + 1)]
    edges = [{"source": i, "target": i + 1} for i in range(1, N)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 18.5ms -> 56.4μs (32664% faster)


def test_large_star_graph():
    # 1 is the center, points to all others: only leaves are last nodes
    N = 1000
    nodes = [{"id": i} for i in range(1, N + 1)]
    edges = [{"source": 1, "target": i} for i in range(2, N + 1)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 37.8μs -> 20.1μs (87.8% faster)


def test_large_disconnected_nodes():
    # 1000 nodes, no edges: all are last nodes, first one is returned
    N = 1000
    nodes = [{"id": i} for i in range(1, N + 1)]
    edges = []
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 1.38μs -> 1.00μs (37.5% faster)


def test_large_complete_graph():
    # Each node has outgoing edges to every other node: no last node
    N = 100
    nodes = [{"id": i} for i in range(1, N + 1)]
    edges = [
        {"source": i, "target": j}
        for i in range(1, N + 1)
        for j in range(1, N + 1)
        if i != j
    ]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 17.3ms -> 193μs (8810% faster)


def test_large_graph_with_one_sink():
    # All nodes point to node N, node N has no outgoing edges
    N = 1000
    nodes = [{"id": i} for i in range(1, N + 1)]
    edges = [{"source": i, "target": N} for i in range(1, N)]
    codeflash_output = find_last_node(nodes, edges)
    result = codeflash_output  # 18.2ms -> 55.2μs (32811% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from src.algorithms.graph import find_last_node

# unit tests


class TestFindLastNodeBasic:
    """Test basic functionality of find_last_node"""

    def test_simple_linear_graph(self):
        # Test a simple A→B→C chain, C should be the last node
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}]
        edges = [{"source": "A", "target": "B"}, {"source": "B", "target": "C"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.54μs -> 1.29μs (96.7% faster)

    def test_single_node_no_edges(self):
        # Test with a single node and no edges
        nodes = [{"id": "A"}]
        edges = []
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.33μs -> 959ns (39.0% faster)

    def test_two_nodes_one_edge(self):
        # Test with two nodes connected by one edge
        nodes = [{"id": "start"}, {"id": "end"}]
        edges = [{"source": "start", "target": "end"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.00μs -> 1.17μs (71.4% faster)

    def test_nodes_with_additional_properties(self):
        # Test that nodes with extra properties still work correctly
        nodes = [
            {"id": 1, "name": "Node A", "value": 100},
            {"id": 2, "name": "Node B", "value": 200},
        ]
        edges = [{"source": 1, "target": 2, "weight": 5}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.92μs -> 1.12μs (70.4% faster)


class TestFindLastNodeMultipleValidNodes:
    """Test behavior when multiple nodes could be 'last' nodes"""

    def test_multiple_leaf_nodes_returns_first(self):
        # Test that when multiple nodes have no outgoing edges, the first one in the list is returned
        nodes = [{"id": "root"}, {"id": "leaf1"}, {"id": "leaf2"}, {"id": "leaf3"}]
        edges = [
            {"source": "root", "target": "leaf1"},
            {"source": "root", "target": "leaf2"},
            {"source": "root", "target": "leaf3"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.17μs -> 1.21μs (79.4% faster)

    def test_tree_structure_multiple_leaves(self):
        # Test a tree with multiple leaf nodes at different levels
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}, {"id": "D"}, {"id": "E"}]
        edges = [
            {"source": "A", "target": "B"},
            {"source": "A", "target": "C"},
            {"source": "B", "target": "D"},
            {"source": "B", "target": "E"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.58μs -> 1.25μs (107% faster)

    def test_order_matters_for_multiple_last_nodes(self):
        # Test that node order in the list determines which is returned
        nodes = [
            {"id": "Z"},  # This one should be returned (first with no outgoing edges)
            {"id": "A"},
            {"id": "Y"},
        ]
        edges = [{"source": "A", "target": "Z"}, {"source": "A", "target": "Y"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.67μs -> 1.08μs (53.8% faster)


class TestFindLastNodeCyclicGraphs:
    """Test behavior with cyclic graphs"""

    def test_simple_cycle_returns_none(self):
        # Test a simple two-node cycle
        nodes = [{"id": "A"}, {"id": "B"}]
        edges = [{"source": "A", "target": "B"}, {"source": "B", "target": "A"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.08μs -> 1.25μs (66.6% faster)

    def test_self_loop_returns_none(self):
        # Test a node with a self-loop
        nodes = [{"id": "A"}]
        edges = [{"source": "A", "target": "A"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.46μs -> 1.08μs (34.6% faster)

    def test_complex_cycle_returns_none(self):
        # Test a cycle involving multiple nodes
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}, {"id": "D"}]
        edges = [
            {"source": "A", "target": "B"},
            {"source": "B", "target": "C"},
            {"source": "C", "target": "D"},
            {"source": "D", "target": "A"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.83μs -> 1.33μs (113% faster)

    def test_cycle_with_tail(self):
        # Test a graph with a cycle and a tail leading to it
        nodes = [{"id": "start"}, {"id": "A"}, {"id": "B"}, {"id": "C"}]
        edges = [
            {"source": "start", "target": "A"},
            {"source": "A", "target": "B"},
            {"source": "B", "target": "C"},
            {"source": "C", "target": "A"},  # Creates cycle A→B→C→A
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.96μs -> 1.33μs (122% faster)


class TestFindLastNodeEmptyInputs:
    """Test edge cases with empty or minimal inputs"""

    def test_empty_nodes_list(self):
        # Test with no nodes
        nodes = []
        edges = []
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 833ns -> 875ns (4.80% slower)

    def test_empty_edges_with_single_node(self):
        # Test with nodes but no edges
        nodes = [{"id": "only"}]
        edges = []
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.21μs -> 958ns (26.2% faster)

    def test_empty_edges_with_multiple_nodes(self):
        # Test with multiple nodes but no edges
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}]
        edges = []
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.29μs -> 958ns (34.9% faster)

    def test_nodes_present_edges_empty(self):
        # Test that empty edges list means all nodes are potential last nodes
        nodes = [{"id": 10}, {"id": 20}, {"id": 30}]
        edges = []
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.29μs -> 1.00μs (29.1% faster)


class TestFindLastNodeAllNodesHaveOutgoingEdges:
    """Test cases where every node has at least one outgoing edge"""

    def test_complete_graph_three_nodes(self):
        # Test a complete graph where every node connects to every other
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}]
        edges = [
            {"source": "A", "target": "B"},
            {"source": "A", "target": "C"},
            {"source": "B", "target": "A"},
            {"source": "B", "target": "C"},
            {"source": "C", "target": "A"},
            {"source": "C", "target": "B"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.67μs -> 1.33μs (100% faster)

    def test_every_node_is_source(self):
        # Test where each node has exactly one outgoing edge
        nodes = [{"id": 1}, {"id": 2}, {"id": 3}]
        edges = [
            {"source": 1, "target": 2},
            {"source": 2, "target": 3},
            {"source": 3, "target": 1},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.38μs -> 1.33μs (78.2% faster)

    def test_multiple_edges_from_each_node(self):
        # Test where nodes have multiple outgoing edges
        nodes = [{"id": "X"}, {"id": "Y"}]
        edges = [
            {"source": "X", "target": "Y"},
            {"source": "X", "target": "Y"},  # Duplicate edge
            {"source": "Y", "target": "X"},
            {"source": "Y", "target": "X"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.08μs -> 1.25μs (66.7% faster)


class TestFindLastNodeComplexStructures:
    """Test complex graph structures"""

    def test_disconnected_components(self):
        # Test a graph with multiple disconnected components
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}, {"id": "D"}]
        edges = [
            {"source": "A", "target": "B"},  # Component 1: A→B
            {"source": "C", "target": "D"},  # Component 2: C→D
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.00μs -> 1.21μs (65.6% faster)

    def test_star_topology(self):
        # Test a star topology with one center and multiple endpoints
        nodes = [
            {"id": "center"},
            {"id": "end1"},
            {"id": "end2"},
            {"id": "end3"},
            {"id": "end4"},
        ]
        edges = [
            {"source": "center", "target": "end1"},
            {"source": "center", "target": "end2"},
            {"source": "center", "target": "end3"},
            {"source": "center", "target": "end4"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.12μs -> 1.29μs (64.5% faster)

    def test_diamond_pattern(self):
        # Test a diamond pattern: A→B→D, A→C→D
        nodes = [{"id": "A"}, {"id": "B"}, {"id": "C"}, {"id": "D"}]
        edges = [
            {"source": "A", "target": "B"},
            {"source": "A", "target": "C"},
            {"source": "B", "target": "D"},
            {"source": "C", "target": "D"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.79μs -> 1.38μs (103% faster)

    def test_complex_dag(self):
        # Test a complex directed acyclic graph
        nodes = [
            {"id": "root"},
            {"id": "mid1"},
            {"id": "mid2"},
            {"id": "mid3"},
            {"id": "leaf1"},
            {"id": "leaf2"},
        ]
        edges = [
            {"source": "root", "target": "mid1"},
            {"source": "root", "target": "mid2"},
            {"source": "mid1", "target": "mid3"},
            {"source": "mid2", "target": "mid3"},
            {"source": "mid3", "target": "leaf1"},
            {"source": "mid3", "target": "leaf2"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 3.46μs -> 1.38μs (151% faster)


class TestFindLastNodeDataStructureVariations:
    """Test different data structure variations"""

    def test_string_ids(self):
        # Test with string IDs
        nodes = [{"id": "alpha"}, {"id": "beta"}, {"id": "gamma"}]
        edges = [
            {"source": "alpha", "target": "beta"},
            {"source": "beta", "target": "gamma"},
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.38μs -> 1.25μs (90.0% faster)

    def test_integer_ids(self):
        # Test with integer IDs
        nodes = [{"id": 100}, {"id": 200}, {"id": 300}]
        edges = [{"source": 100, "target": 200}, {"source": 200, "target": 300}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.50μs -> 1.29μs (93.6% faster)

    def test_mixed_type_ids(self):
        # Test with mixed type IDs (string and int)
        nodes = [{"id": "start"}, {"id": 42}, {"id": "end"}]
        edges = [{"source": "start", "target": 42}, {"source": 42, "target": "end"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.62μs -> 1.21μs (117% faster)

    def test_edges_with_extra_fields(self):
        # Test that edges with extra fields don't affect the result
        nodes = [{"id": "A"}, {"id": "B"}]
        edges = [
            {
                "source": "A",
                "target": "B",
                "weight": 10,
                "color": "red",
                "metadata": {"foo": "bar"},
            }
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.83μs -> 1.12μs (62.9% faster)

    def test_minimal_node_structure(self):
        # Test with minimal node structure (only id field)
        nodes = [{"id": 1}, {"id": 2}]
        edges = [{"source": 1, "target": 2}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.96μs -> 1.17μs (67.8% faster)

    def test_node_id_zero(self):
        # Test that ID of 0 (falsy value) works correctly
        nodes = [{"id": 0}, {"id": 1}]
        edges = [{"source": 0, "target": 1}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.88μs -> 1.17μs (60.7% faster)

    def test_node_id_empty_string(self):
        # Test that empty string ID works correctly
        nodes = [{"id": ""}, {"id": "nonempty"}]
        edges = [{"source": "", "target": "nonempty"}]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 1.92μs -> 1.12μs (70.4% faster)


class TestFindLastNodeLargeScale:
    """Test performance and scalability with large data samples"""

    def test_large_linear_chain(self):
        # Test a long linear chain of nodes
        size = 1000
        nodes = [{"id": i} for i in range(size)]
        edges = [{"source": i, "target": i + 1} for i in range(size - 1)]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 18.3ms -> 56.0μs (32586% faster)

    def test_large_star_topology(self):
        # Test a star with many endpoints
        num_endpoints = 1000
        nodes = [{"id": "center"}] + [{"id": f"end_{i}"} for i in range(num_endpoints)]
        edges = [
            {"source": "center", "target": f"end_{i}"} for i in range(num_endpoints)
        ]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 38.8μs -> 19.6μs (97.9% faster)

    def test_large_graph_single_last_node(self):
        # Test a large graph where only one node has no outgoing edges
        size = 500
        nodes = [{"id": i} for i in range(size)]
        # Create edges so that all nodes except the last one have outgoing edges
        edges = []
        for i in range(size - 1):
            # Each node (except last) connects to the next node
            edges.append({"source": i, "target": i + 1})
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 4.58ms -> 28.5μs (15953% faster)

    def test_large_graph_many_edges(self):
        # Test a graph with many nodes and many edges
        num_nodes = 100
        nodes = [{"id": i} for i in range(num_nodes)]
        edges = []
        # Create a complex edge structure where each node connects to multiple others
        for i in range(num_nodes - 1):
            for j in range(i + 1, min(i + 5, num_nodes)):
                edges.append({"source": i, "target": j})
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 723μs -> 13.0μs (5446% faster)

    def test_large_binary_tree(self):
        # Test a complete binary tree structure
        depth = 9  # Creates 2^9 - 1 = 511 nodes
        nodes = []
        edges = []
        node_id = 0

        # Build binary tree level by level
        for level in range(depth):
            level_start = 2**level - 1
            level_end = 2 ** (level + 1) - 1

            for i in range(level_start, level_end):
                nodes.append({"id": i})

                # Add children if not at last level
                if level < depth - 1:
                    left_child = 2 * i + 1
                    right_child = 2 * i + 2
                    edges.append({"source": i, "target": left_child})
                    edges.append({"source": i, "target": right_child})

        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 2.35ms -> 19.2μs (12118% faster)
        # First leaf node (leftmost node at the last level)
        first_leaf = 2 ** (depth - 1) - 1

    def test_large_disconnected_components(self):
        # Test many small disconnected components
        num_components = 200
        nodes = []
        edges = []

        for comp in range(num_components):
            # Each component is a simple A→B chain
            node_a = f"comp{comp}_a"
            node_b = f"comp{comp}_b"
            nodes.append({"id": node_a})
            nodes.append({"id": node_b})
            edges.append({"source": node_a, "target": node_b})

        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 12.0μs -> 12.8μs (6.52% slower)

    def test_large_graph_all_nodes_have_edges(self):
        # Test a large cycle where no node is a last node
        size = 1000
        nodes = [{"id": i} for i in range(size)]
        edges = [{"source": i, "target": (i + 1) % size} for i in range(size)]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 18.3ms -> 55.8μs (32613% faster)

    def test_many_nodes_few_edges(self):
        # Test with many nodes but very few edges
        num_nodes = 1000
        nodes = [{"id": i} for i in range(num_nodes)]
        # Only first 5 nodes have outgoing edges
        edges = [{"source": i, "target": i + 1} for i in range(5)]
        codeflash_output = find_last_node(nodes, edges)
        result = codeflash_output  # 3.79μs -> 1.58μs (139% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-find_last_node-mk3e8gso and push.