You are given a **directed acyclic graph (DAG)** that represents trigger dependencies between tasks. - Each node represents a task. - There is exactly one **entry node**. - When a node is **triggered** once, it immediately triggers **each of its outgoing neighbors once**. - A node may have multiple incoming edges; its total trigger count is the **sum of triggers from all its parents**. - The entry node is triggered exactly **once** initially. Your job is to compute how many times **each node** is triggered. ### Input - A list of directed edges `edges`, where each edge is a pair `(u, v)` meaning there is an edge `u -> v`. - A designated `entry` node ID. - You may assume: - The graph is acyclic. - All nodes that appear in `edges` are valid nodes. - Node IDs can be strings or integers (you can pick a representation and document it). Example: - Nodes: `A, B, C, D, E, F` - Edges: - `A -> B` - `B -> C` - `B -> D` - `C -> D` - `D -> E` - `D -> F` - `E -> F` - Entry node: `A` Trigger propagation: - `A` is triggered once (given). - `B` is triggered once (from `A`). - `C` is triggered once (from `B`). - `D` is triggered twice (once from `B`, once from `C`). - `E` is triggered twice (both from `D`). - `F` is triggered four times (twice from `D`, twice from `E`). So the result is something equivalent to: ```text A: 1 B: 1 C: 1 D: 2 E: 2 F: 4 ``` ### Task Implement a function **in Python** with a signature such as: ```python def count_triggers(edges, entry): """Return a mapping from node to its trigger count.""" ``` The function should: - Validate that all reachable nodes from `entry` are handled. - Run efficiently for graphs with up to around 10^5 nodes and 10^5 edges. You may assume there are **no cycles** in the input graph.

from collections import defaultdict, deque

def solution(edges, entry):
    adj = defaultdict(list)
    for u, v in edges:
        adj[u].append(v)

    reachable = {entry}
    stack = [entry]
    while stack:
        u = stack.pop()
        for v in adj.get(u, []):
            if v not in reachable:
                reachable.add(v)
                stack.append(v)

    indegree = {node: 0 for node in reachable}
    for u, v in edges:
        if u in reachable and v in reachable:
            indegree[v] += 1

    counts = defaultdict(int)
    counts[entry] = 1

    queue = deque(node for node in reachable if indegree[node] == 0)
    topo_order = []

    while queue:
        u = queue.popleft()
        topo_order.append(u)
        for v in adj.get(u, []):
            if v not in reachable:
                continue
            counts[v] += counts[u]
            indegree[v] -= 1
            if indegree[v] == 0:
                queue.append(v)

    if len(topo_order) != len(reachable):
        raise ValueError('Input contains a cycle in the reachable subgraph.')

    return {node: counts[node] for node in topo_order}