Given the head of a linked list, return *the node where the cycle begins. If there is no cycle, return *null.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer. Internally, pos is used to denote the index of the node that tail's next pointer is connected to (**0-indexed**). It is -1 if there is no cycle. **Note that** pos **is not passed as a parameter**.

**Do not modify** the linked list.

**Example 1:**

**Input:** head = [3,2,0,-4], pos = 1
**Output:** tail connects to node index 1
**Explanation:** There is a cycle in the linked list, where tail connects to the second node.

**Example 2:**

**Input:** head = [1,2], pos = 0
**Output:** tail connects to node index 0
**Explanation:** There is a cycle in the linked list, where tail connects to the first node.

**Example 3:**

**Input:** head = [1], pos = -1
**Output:** no cycle
**Explanation:** There is no cycle in the linked list.

**Constraints:**

The number of the nodes in the list is in the range [0, 104].

-105 <= Node.val <= 105

pos is -1 or a

**valid index**in the linked-list.

**Explanation:**

** **We have to solve two parts:

Whether a cycle exists or not?

What is the entry point?

To Solved whether a cycle exists or not, we use Cycle detection theorem. Where we use two pointers Fast and Slow, they move at different speeds. And if they meet at some point, then cycle exists.

To solve the entry point, we are going to use a simple mathematical knowledge,

Assume the distance from head to the start of the loop is **x1**
The distance from the start of the loop to the point fast and slow meet is **x2**
The distance from the point fast and slow meet to the start of the loop is **x3**
What is the distance fast moved?

x1 + x2 + x3 + x2

What is the distance slow moved?

x1 + x2

And their relationship?

x1 + x2 + x3 + x2 = 2 (x1 + x2)

Solving this,

2x2+x1+x3 = 2x2+2x1

x3 = 2x1-x1

x3=x1

so, x3 (distance from slow and fast met to entry point of cycle) = x1 (distance from head of linked list to entry point of cycle)

We use two pointers s and s2 to move both the distance, and meeting point is the solution.

**Solution:**

```
/**
* Definition for singly-linked list.
* class ListNode {
* int val♠
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while(fast!=null && fast.next!=null)
{
fast = fast.next.next;
slow = slow.next;
if(fast == slow)
{
ListNode slow2 = head;
while(slow2!=slow)
{
slow = slow.next;
slow2 = slow2.next;
}
return slow;
}
}
return null;
}
}
```

## Comentarios