The report that dies on one tenant

import java.util.*;

/**
 * Solution: the nightly cost-allocation report.
 *
 * Two defects, two different regions of memory, two unrelated fixes.
 *
 *   Bug 1 (stack) — the roll-up recursed over an org chart that the admin had
 *       accidentally made cyclic, so the recursion never terminated. A deeper
 *       stack only postpones that. The fix is to carry the current path and
 *       refuse to walk an edge that re-enters it: the bad data gets reported
 *       instead of crashing the job.
 *
 *   Bug 2 (heap) — every row was accumulated before any row was written, so
 *       peak memory scaled with the tenant. The fix is to write each row as
 *       soon as it is final, which makes peak memory a constant.
 *
 * Worth being explicit about why the traversal is now iterative. Cycle
 * detection alone would fix the crash. Moving the frames onto an explicit
 * ArrayDeque also moves the depth limit from the thread's stack — a fixed
 * reservation you cannot grow at runtime — onto the heap, which is where a
 * limit proportional to the data belongs.
 */
public class Solution {

    /** Peak rows held in memory at once. The heap half of this incident. */
    static int peakBuffered = 0;

    record Team(int id, String name, int spendPaise) {}

    record Row(String team, int ownSpend, int rolledUpSpend) {}

    static final class ReportSink {
        int written = 0;

        void write(Row row) {
            written++;
            // Exactly one Row is live at a time now, whatever the tenant size.
            peakBuffered = Math.max(peakBuffered, 1);
        }
    }

    static Map<Integer, List<Integer>> childrenOf = new HashMap<>();
    static Map<Integer, Team> teams = new HashMap<>();

    static void loadTenant() {
        int[][] chart = {
                {1, 0}, {2, 1}, {3, 1}, {4, 2}, {5, 2}, {6, 3}, {7, 3}, {8, 6}, {9, 6},
        };
        for (int[] row : chart) {
            int id = row[0], parent = row[1];
            teams.put(id, new Team(id, "team-" + id, id * 1000));
            childrenOf.computeIfAbsent(parent, k -> new ArrayList<>()).add(id);
        }
        // The admin's edit, left in place on purpose: the job must survive it.
        childrenOf.computeIfAbsent(8, k -> new ArrayList<>()).add(3);
    }

    /** One suspended call, made explicit. This is what a frame held. */
    private static final class Frame {
        final int teamId;
        final Iterator<Integer> children;
        int total;

        Frame(int teamId) {
            this.teamId = teamId;
            this.children = childrenOf.getOrDefault(teamId, List.<Integer>of()).iterator();
            Team team = teams.get(teamId);
            this.total = team == null ? 0 : team.spendPaise();
        }
    }

    /**
     * FIX 1 + FIX 2: post-order roll-up on an explicit stack, with the current
     * path tracked so a cycle is reported rather than followed, and each row
     * written the moment its subtotal is final.
     */
    static int rollUp(int rootId, ReportSink sink, List<String> problems) {
        Deque<Frame> stack = new ArrayDeque<>();
        Set<Integer> onPath = new HashSet<>();

        stack.push(new Frame(rootId));
        onPath.add(rootId);
        int rootTotal = 0;

        while (!stack.isEmpty()) {
            Frame frame = stack.peek();

            if (frame.children.hasNext()) {
                int child = frame.children.next();
                if (onPath.contains(child)) {
                    problems.add("cycle: team-" + frame.teamId + " -> team-" + child
                            + " re-enters the current path; edge skipped");
                    continue;
                }
                stack.push(new Frame(child));
                onPath.add(child);
                continue;
            }

            stack.pop();
            onPath.remove(frame.teamId);

            Team team = teams.get(frame.teamId);
            if (team != null) {
                sink.write(new Row(team.name(), team.spendPaise(), frame.total));
            }

            Frame parent = stack.peek();
            if (parent != null) {
                parent.total += frame.total;
            } else {
                rootTotal = frame.total;
            }
        }
        return rootTotal;
    }

    public static void main(String[] args) {
        loadTenant();

        boolean completed = false;
        ReportSink sink = new ReportSink();
        List<String> problems = new ArrayList<>();

        int total = rollUp(0, sink, problems);
        completed = true;

        for (String problem : problems) {
            System.out.println("data problem: " + problem);
        }

        boolean flatMemory = peakBuffered <= 2;

        System.out.println();
        System.out.println("rows written                 : " + sink.written);
        System.out.println("tenant total (paise)         : " + total);
        System.out.println("peak rows buffered in memory : " + peakBuffered);
        System.out.println();
        System.out.println("report completed             : " + completed);
        System.out.println("memory flat regardless of size: " + flatMemory);
        System.out.println(completed && flatMemory ? "PASS" : "FAIL");
    }
}