Implement a `Spreadsheet` class that supports cells holding either a literal integer or a **formula** that references other cells. This is the core of a spreadsheet calculation engine: when a cell that others depend on changes, every dependent cell must reflect the new value. ## API Implement the following two methods: - `set_cell(cell_id: str, value)` — assign `value` to the cell identified by `cell_id`. `value` is either: - an **integer** (the cell stores that literal), or - a **formula string** of the form `"=<term>(+<term>)*"`, where each `<term>` is either a non-negative integer literal or a cell reference (e.g. `"=A1+B2+10"`). The formula's value is the sum of its terms, with each cell reference resolved to that cell's current value. - `get_cell(cell_id: str) -> int` — return the current integer value of the cell. If a cell has never been set, its value is `0`. A formula always reflects the **latest** values of the cells it references. For example, if `A3 = "=A1+A2"` and `A1` is later changed, a subsequent `get_cell("A3")` must use the new `A1`. Updates propagate transitively (a formula may reference a cell that is itself a formula). ## Cell IDs and formula syntax - A cell id is one or more uppercase letters followed by one or more digits: `A1`, `B2`, `AA10`. - Cell references inside a formula use the same format. - Terms in a formula are separated by `+` with no spaces. Each term is either a non-negative integer (e.g. `10`) or a cell reference (e.g. `B2`). You may assume every formula passed in is syntactically valid. ## Cyclic dependencies A `set_cell` call that would introduce a **dependency cycle** (a cell that, directly or transitively, depends on itself) is invalid. When this happens, raise a `ValueError` and leave the spreadsheet **unchanged** (the offending assignment must not take effect, and all previously stored cells keep their values). ## Performance note In the target workload, `set_cell` is called far more often than `get_cell`. Your design should make writes cheap and is free to defer formula evaluation until a value is actually read. ## Example ```text s = Spreadsheet() s.set_cell("A1", 5) s.set_cell("A2", 10) s.set_cell("A3", "=A1+A2") # A3 depends on A1 and A2 s.get_cell("A3") # -> 15 s.set_cell("A1", 7) # update A1 s.get_cell("A3") # -> 17 (reflects the new A1) s.set_cell("A4", "=A3+3") s.get_cell("A4") # -> 20 s.get_cell("B9") # -> 0 (never set) s.set_cell("A1", "=A4") # cycle: A1 -> A4 -> A3 -> A1 => raises ValueError s.get_cell("A1") # -> 7 (unchanged after the rejected write) ``` ## Constraints - At most $10^4$ distinct cells. - At most $10^5$ total `set_cell` / `get_cell` calls. - Every integer value and every evaluated cell value fits in a signed 64-bit integer. - Formula references may point to cells that have not been set yet; treat those as `0` until they are.