Solve 142. Linked List Cycle II (step 1, 2)

142. Linked List Cycle II/note.md

@@ -0,0 +1,24 @@
+# step1
+
+set を使用した space complexity O(N)の方法はすぐに思いつく.
+問題は O(1)の場合. Floyd のアルゴリズムで, 合流までの回数などを用いて計算すれば求まりそうだが, あまり自明ではないだろう. Brent のアルゴリズムを使えば求められるだろうが, これも常識の範囲には入らず, 読むには負荷がかかるのではないだろうか.
+ということで今回は set を使用したアルゴリズムで書く.
+
+やはり Floyd の方法でも解く.
+アルゴリズムは editorial にある通り. ループは 2\*a+b 回ほどまわる.
+メソッドの命名が統一されていないが, leetcode の都合上 detectCycle は変更できないのでしかたがない.
+
+# step2
+
+見た回答
+
+- Google docs の sample answer
+- https://discord.com/channels/1084280443945353267/1195700948786491403/1196010117120925777
+  - キャンベルの法則を知る
+- https://discord.com/channels/1084280443945353267/1200089668901937312/1205725280556023898
+  - "エッジケースを先にケアしておくことで読む人がエッジケースの考慮ができてるかを確認する手間が減るメリットもある"というのは参考になる.
+  - メソッドの中で関数を定義するのと, クラスに内部用のメソッドを追加するのだとどういうメリット・デメリットがあるだろうか. 他にも catchup point を知りたいメソッドがある場合は, メソッドを追加する方法が良いだろう. 一方で"\_"から始まるメソッドは完璧には private ではないというデメリットもある.
+  - from_start, from_catchup という命名は良いと思った. また, 自分のコードの collision という命名は少々わかりにくい.
+
+以上を参考に書く.
+set を用いた方法はそんなに変わらず.

142. Linked List Cycle II/step1_floyd.py

@@ -0,0 +1,27 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def _get_collision_node(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        fast_cursor = head
+        slow_cursor = head
+        while fast_cursor and fast_cursor.next:
+            fast_cursor = fast_cursor.next.next
+            slow_cursor = slow_cursor.next
+            if fast_cursor == slow_cursor:
+                return fast_cursor
+        return None
+
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        collision_node = self._get_collision_node(head)
+        if not collision_node:
+            return None
+        head_cursor = head
+        collision_cursor = collision_node
+        while head_cursor != collision_cursor:
+            head_cursor = head_cursor.next
+            collision_cursor = collision_cursor.next
+        return head_cursor

142. Linked List Cycle II/step1_set.py

@@ -0,0 +1,15 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        seen_nodes = set()
+        while head:
+            if head in seen_nodes:
+                return head
+            seen_nodes.add(head)
+            head = head.next
+        return None

142. Linked List Cycle II/step2_floyd.py

@@ -0,0 +1,27 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def _get_catchup_node(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        fast_cursor = head
+        slow_cursor = head
+        while fast_cursor and fast_cursor.next:
+            fast_cursor = fast_cursor.next.next
+            slow_cursor = slow_cursor.next
+            if fast_cursor == slow_cursor:
+                return fast_cursor
+        return None
+
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        catchup_node = self._get_catchup_node(head)
+        if not catchup_node:
+            return None
+        from_head = head
+        from_catchup = catchup_node
+        while from_head != from_catchup:
+            from_head = from_head.next
+            from_catchup = from_catchup.next
+        return from_head

142. Linked List Cycle II/step2_set.py

@@ -0,0 +1,15 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        seen_nodes = set()
+        while head:
+            if head in seen_nodes:
+                return head
+            seen_nodes.add(head)
+            head = head.next
+        return None

142. Linked List Cycle II/step3_floyd.py

@@ -0,0 +1,27 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def _search_catchup_node(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        fast_cursor = head
+        slow_cursor = head
+        while fast_cursor and fast_cursor.next:
+            fast_cursor = fast_cursor.next.next
+            slow_cursor = slow_cursor.next
+            if fast_cursor == slow_cursor:
+                return fast_cursor
+        return None
+
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        catchup_node = self._search_catchup_node(head)
+        if not catchup_node:
+            return None
+        from_start = head
+        from_catchup = catchup_node
+        while from_start != from_catchup:
+            from_start = from_start.next
+            from_catchup = from_catchup.next
+        return from_start

142. Linked List Cycle II/step3_set.py

@@ -0,0 +1,16 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
+        seen_nodes = set()
+        cursor = head
+        while cursor:
+            if cursor in seen_nodes:
+                return cursor
+            seen_nodes.add(cursor)
+            cursor = cursor.next
+        return None