Deep Copy a Random-Pointer List

A linked list has n nodes in next-pointer order. Each node contains an integer value and a random pointer that may target any node or be null.
The list is encoded by nodes, where nodes[i] = [value, randomIndex]. The next pointer of node i targets node i + 1, except for the last node. A randomIndex of -1 means null.
Create a deep copy whose next and random pointers target only copied nodes. For this exercise, after copying, mutate the original node at mutationIndex: set its value to newValue and its random pointer to newRandomIndex.
Return two encoded snapshots in order: the mutated original list, then the unchanged deep copy.

Function
copyAndMutateRandomList(nodes: int[][], mutationIndex: int, newValue: int, newRandomIndex: int) → int[][][]

Examples
Example 1
nodes = [[7,-1],[13,0],[11,4],[10,2],[1,0]]
mutationIndex = 1
newValue = 130
newRandomIndex = 4
return = [[[7,-1],[130,4],[11,4],[10,2],[1,0]],[[7,-1],[13,0],[11,4],[10,2],[1,0]]]
The second original node changes to [130,4]. The second copied node remains [13,0], so the copy is independent.
Example 2
nodes = [[1,1],[2,1]]
mutationIndex = 0
newValue = 10
newRandomIndex = -1
return = [[[10,-1],[2,1]],[[1,1],[2,1]]]
The first original node loses its random pointer. The copy retains both original random references.
Example 3
nodes = [[5,0]]
mutationIndex = 0
newValue = 6
newRandomIndex = -1
return = [[[6,-1]],[[5,0]]]
The one-node copy keeps its self-random pointer even after the original is changed.

Constraints
1 <= nodes.length <= 10^4.
Every row of nodes contains exactly two integers.
-10^9 <= nodes[i][0], newValue <= 10^9.
Every random index and newRandomIndex is -1 or an index from 0 through nodes.length - 1.
0 <= mutationIndex < nodes.length.

Here's the trick. The input is already encoded as indices, so you don't need real node objects at all. A deep copy of the encoded list is just a fresh copy of every row. Build the copy with new inner arrays, not a shallow reference to the same rows. Then apply the mutation to the original only: set nodes[mutationIndex] to [newValue, newRandomIndex]. The edge case that breaks naive solutions is aliasing. If you reuse the same inner arrays in both snapshots, the mutation shows up in both and your copy fails Example 1. Also watch -1 for null random pointers, and the single-node self-pointer case in Example 3. If you build real nodes, use a hash map from original to clone in two passes, one to create and one to wire next and random. StealthCoder is the hedge if you freeze on the output shape, which is a list of two snapshots, original first.

Memorize the pattern. If you can't, run StealthCoder. The proctor sees the IDE. They don't see what's behind it.