Given a category tree, return display paths such as `Root / Child / Leaf`.

Implement FlattenPaths(Category root) returning every node path in depth-first order. Each path joins names with /. Child order is the order given. Protect against cycles by throwing if the same node id appears twice in the current path.

Tree: Books -> Programming -> C# Output: Books, Books / Programming, Books / Programming / C#

• Null root returns an empty list.
• Every node has an id and name.
• Depth-first output includes the root path.
• A cycle in the current traversal path throws InvalidOperationException.

I would use a recursive DFS with a path list and a set of ids currently in the path. When I enter a node, I add its id to the active set and its name to the path, emit the joined path, then visit children. On exit, I remove both. The active set catches cycles without blocking the same id in a different branch unless the domain says ids must be globally unique.

public sealed record Category(string Id, string Name, IReadOnlyList<Category> Children);

public static IReadOnlyList<string> FlattenPaths(Category? root)
{
    if (root is null)
    {
        return Array.Empty<string>();
    }

    var result = new List<string>();
    var path = new List<string>();
    var activeIds = new HashSet<string>(StringComparer.Ordinal);

    void Visit(Category node)
    {
        if (!activeIds.Add(node.Id))
        {
            throw new InvalidOperationException($"Cycle detected at category '{node.Id}'.");
        }

        path.Add(node.Name);
        result.Add(string.Join(" / ", path));

        foreach (var child in node.Children ?? Array.Empty<Category>())
        {
            Visit(child);
        }

        path.RemoveAt(path.Count - 1);
        activeIds.Remove(node.Id);
    }

    Visit(root);
    return result;
}

The traversal is O(n * p) if joining the path costs p per node. Space is O(d) for recursion depth and current path, plus O(n) for output.

• Null root.
• A single node.
• Deep nesting.
• A node with no children.
• A cycle that would otherwise recurse forever.

• Use a deep chain to catch path cleanup mistakes.
• Use siblings to verify one sibling's path does not leak into the next.
• Use a cycle to verify active-path detection.

• Using one mutable path without removing names on return.
• No cycle handling.
• Changing child order unexpectedly.
• Throwing on repeated names instead of repeated ids.