Linked List Cycle II

Odd Even Linked List

Construct Binary Tree from Preorder & Inorder

Find the index where a cycle begins in a linked list represented by next-node indices, or -1 if there is none.

An array `nextIndices` describes a linked list whose head is node 0; each value is the next node's index, or `-1` for null. If the list has a cycle, return the index of the node where the cycle begins. If there is no cycle, return `-1`.

Do not modify the list — treat `nextIndices` as read-only, the same encoding used by `linked-list-cycle`.

**Input / output**
- Input: `nextIndices: int[]`
- Output: `int`, the index where the cycle begins, or `-1`

## Example
```json
Input: {"nextIndices":[1,2,0,-1]}
Output: 0
```
(Following 0 -> 1 -> 2 -> 0 revisits node 0, so the cycle begins at index 0. Node 3 is unreachable, which is fine — only the path from the head matters.)

## Constraints
- 0 <= nextIndices.length <= 10,000
- Every entry is `-1` or a valid index into `nextIndices`
- Following indices from 0 either reaches `-1` or eventually repeats an index (a genuine cycle)

## Follow-up
Can you solve it using O(1) extra space (Floyd's cycle-detection / tortoise-and-hare), without a visited-set?

The key pattern is: Floyd's tortoise-and-hare — advance slow by one step and fast by two; if they meet inside a cycle, resetting one pointer to the head and advancing both by one step at a time makes them meet exactly at the cycle's start.

Recognize the Pattern

Advance one state transition at a time. Mark or update state before exploring dependent work.

Build the Algorithm

Test empty or minimal input, skewed shapes, duplicates where allowed, and impossible outcomes.

Check Edge Cases

Time: O(n) — each pointer visits at most O(n) nodes before either reaching the end or meeting inside the cycle. Space: O(1) — only a constant number of index variables are used, no visited-set.

This problem reuses the same plain-array `nextIndices` encoding as `linked-list-cycle` (rather than a real `ListNode` structure), since a genuinely cyclic linked-list value isn't something the judge's structural list/tree conversion supports as an input or output — the array of next-indices sidesteps that entirely while still exercising real cycle-detection logic in all 5 languages.