ดูต้นฉบับสำหรับ Biconnectedness (ค่ายวันที่ 11 มีนาคม 2551)

กำหนด undirected graph <math>G=(V,E)\,</math> ซึ่งเป็นกราฟต่อเนื่อง ใดๆ 
* เราเรียก vertex <math>v\,</math> ว่าเป็น '''articulation point''' ถ้่าเราตัด <math>v\,</math> และ edge ที่ต่อกับมันทั้งหมดออกไปออกจากกราฟแล้วจะทำให้กราฟเป็นกราฟไม่ต่อเนื่อง
* เราเรียก edge <math>e\,</math> ว่าเป็น '''bridge''' ถ้าเราตัด <math>e\,</math> ออกจากกราฟแล้วจะทำให้กราฟเป็นกราฟไม่ต่อเนื่อง
* เรากล่าวว่า edge สอง edge ใดๆ อยู่ใน '''biconnected component''' เดียวกันก็ต่อเมื่อมี simple cycle ที่มี edge ทั้งสองนั้นอยู่ภายใน

จะเห็นได้ว่าความสัมพันธ์ "อยู่ใน biconnected component เดียวกัน" จะแบ่ง edge ออกเป็นกลุ่มๆ ซึ่งเราเรียกกลุ่มเหล่านั้นว่า biconnected component (นั่นแหละ)

ภาพต่อไปนี้แสดง articulation point (vertex สีแดง), bridge (edge เล็กบางสีแดง), และ biconnected component (edge ที่ไม่ใช่ bridge ที่อยู่ใน biconnected component เดียวกัน จะมีสีเดียวกัน) ของกราฟต่อเนื่องกราฟหนึ่ง

[[ภาพ:biconnectedness-01.JPG|500px]]

== การหา articulation point ==
เราสามารถหา articulation point ทั้งหมดของกราฟที่กำหนดให้ได้ในเวลา <math>O(|V|+|E|)\,</math> โดยการทำ DFS เพื่อคำนวณข้อมูลเสริมบางอย่างของ vertex ทุก vertex ในกราฟ หลังจากนั้น เราจะนำข้อมูลนี้ไปประกอบการตัดสินใจว่า vertex ที่กำหนดให้เป็น articulation point หรือเปล่า

ก่อนจะมาพูดถึงนิยามของข้อมูลเสริมนี้ เรามาสังเกตกันก่อนว่าการที่ vertex <math>v\,</math> ใด ในกราฟจะเป็น articulation point หรือไม่มันจะต้องมีสมบัติอย่างไร ในที่นี้ เราจะสมมติว่าเราได้ทำ DFS บนกราฟนี้ครั้งหนึ่งแล้ว และเราจะแยกการพิจารณาเป็นสองกรณี

==== 1. <math>v\,</math> เป็น root ของ DFS tree ====
สังเกตว่าถ้า root มีลูกมากกว่าหนึ่งตัว หมายความว่าถ้าเราจะเริ่มเดินจาก vertex ใน subtree ของลูกตัวหนึ่ง ไปยัง vertex ใน subtree ของลูกอีกตัวหนึ่ง เราต้องเดินผ่าน root เสมอ ดังนั้นถ้าตัด root ออกกราฟก็จะขาดออกจากกันเป็นสองส่วน (เพราะไม่มีเส้นทางเชื่อมระหว่าง vertex ใน subtree 2 ต้นใดๆ อีกต่อไป) 

แต่ถ้า root มีลูกแค่ตัวเดียว แสดงว่าการเดินทางระหว่าง vertex คู่ใดๆ ในกราฟไม่มีความจำเป็นต้องผ่าน root อีกต่อไป ดังนั้นถ้าตัด root ออกก็จะไม่กระทบกระเทือนต่อความต่อเนื่องกันของกราฟ

ด้วยเหตุนี้ '''root ของ DFS tree จะเป็น articulation point ก็ต่อเมื่อมันมีลูกอย่างน้อยสองตัวเท่านั้น'''

==== 2. <math>v\,</math> เป็น internal vertex ของ DFS tree ====
พิจารณารูปข้างล่างนี้

[[ภาพ:biconnectedness-02.JPG|300px]]

เราสามารถแบ่งลูกของ <math>v\,</math> ใน DFS ออกได้เป็น 3 กรณี
# กรณีแรกคือกรณีเหมือน <math>x\,</math> กล่าวคือใน subtree ที่มี root อยู่ที่ <math>x\,</math> มี back edge พุ่งออกมาขึ้นไปต่อกับบรรพบุรุษของ <math>v\,</math> บางตัว
# กรณีที่สองคือกรณีเหมือน <math>y\,</math> กล่าวคือใน subtree ที่มี root อยู่ที่ <math>y\,</math> มี back edge พุ่งขึ้นออกมาต่อกับ <math>v\,</math> เอง
# กรณีที่สองคือกรณีเหมือน <math>z\,</math> กล่าวคือใน subtree ที่มี root อยู่ที่ <math>z\,</math> ไม่มี back edge พุ่งขึ้นมาเหนือหรืออยู่ในระดับเดียวกับ <math>v\,</math> เลย

ถ้าเราตัด <math>v\,</math> ออกแล้วจะเกิดอะไรขึ้น?
* ในกรณี <math>x\,</math>, subtree ที่มี root อยู่ที่ <math>x\,</math> จะยังไม่ขาดออกจากกราฟเนื่องจากมันยังมี back edge ไปเชื่อมกับส่วนบนของกราฟอยู่
* แต่ในกรณี <math>y\,</math> กับ <math>z\,</math>, subtree ที่มี root อยู่ที่ vertex ทั้่งสองจะขาดออกจากกราฟทันที

ดังนั้น <math>v\,</math> จะเป็น articulation point ก็ต่อเมื่อมันมีลูกสักตัวที่มีลักษณะเหมือน <math>y\,</math> หรือ <math>z\,</math> กล่าวคือ '''ใน subtree ของลูกของลูกตัวนั้นจะไม่มี back edge พุ่งขึ้นไปต่อกับ <math>v\,</math> หรือบรรพบุรุษของ <math>v\,</math>'''

=== ข้อมูลเสริม <math>low[v]\,</math> ===
ปัญหาสำคัญคือเราจะรู้ได้อย่างไรว่า subtree ที่มี root ที่ลูกของ <math>v\,</math> จะมีหรือไม่มี back edge ที่ต่อขึ้นไปสูงกว่า <math>v\,</math>? 

สิ่งที่เราจะทำคือเราจะเก็บว่าสำหรับ vertex <math>v\,</math> ทุกตัว เราจะคำนวณหา vertex ที่ "สูง" ทีุ่สุดใน tree ที่มี back edge พุ่งออกจาก subtree ที่มี root อยู่ที่ <math>v\,</math> ไปถึง 

แต่เราจะบอกได้อย่างไรว่า vertex ไหน "สูง" หรือ vertex ไหน "ต่ำ"? คำตอบคือเราสามารถใช้สมบัติวงเล็บของ discovery time เข้ามาช่วยได้ (ถ้าจำไม่ได้ ดูเรื่องสมบัติวงเล็บที่[[ชนิดของ edge ใน DFS tree (ค่ายวันที่ 11 มีนาคม 2551)|หน้านี้]]) กล่าวคือ ถ้า <math>a\,</math> อยู่ "สูง" กว่า <math>b\,</math> ใน DFS tree แล้ว <math>d[a] < d[b]\,</math> เสมอ ดังนั้นเราสามารถตัดสินว่า vertex ใดอยู่สูงกว่าหรือต่ำกว่าใน tree ได้โดยการเปรียบเทียบค่า discovery time ของ vertex เหล่านั้น

อย่างไรก็ดี ประเดี๋ยวคุณจะได้รู้ว่าเราไม่ีมีความจำเป็นต้องเก็บ "ตัว vertex" เราแค่เก็บค่า discovery time ที่ต่ำที่สุดก็เพียงพอ เพื่อความสะดวก เราจะนิยามค่า discovery time ที่ต่ำสุดนี้่ว่า <math>low[v]\,</math> ซึ่งมันควรจะมีความหมายตามข้างล่างนี้:
:''<math>low[v]\,</math> ควรมีค่าเท่ากับ discover time ที่ต่ำที่สุดของ vertex <math>w\,</math> บางตัวที่ back edge <math>(u,w)\,</math> สำหรับ vertex <math>u\,</math> บาง vertex ใน subtree ของ DFS tree ที่มี root อยู่ที่ <math>v\,</math>''

แต่นิยามข้างบนนี้ยังไม่รัดกุมนัก เพราะถ้าหากมีกรณีที่ subtree ที่มี root อยู่ที่ <math>v\,</math> ไม่มี back edge เลยสักเส้น แล้วเราจะให้ <math>low[v]\,</math> มีค่าเท่าไหร่?

เราอาจจะให้ในกรณีนี้ <math>low[v]\,</math> มีค่าเท่ากับ <math>\infty\,</math> แต่ในเอกสารฉบับนี้จะนิยามค่า <math>low[v]\,</math> ตามหนังสือ CLRS กล่าวคือ เราจะให้ <math>low[v]\,</math> เป็นค่าที่ต่ำที่สุดระหว่าง <math>d[v]\,</math> กับ discovery time ของ vertex ที่ back edge ต่อไปถึง

เราจึงสามารถเขียนนิยาม <math>low[v]\,</math> อย่างเป็นทางการได้ดังนี้

:<math>low[v] = \begin{cases} 
d[v], \\ 
d[w]\ : \mathrm{where}\ (u,w)\ \mathrm{is}\ \mathrm{a}\ \mathrm{back}\ \mathrm{edge}\ \mathrm{and}\ u\ \mathrm{is}\ \mathrm{a}\ \mathrm{vertex}\ \mathrm{in}\ \mathrm{the}\ \mathrm{subtree}\ \mathrm{rooted}\ \mathrm{at}\ v.
\end{cases} \,</math>

=== การคำนวณค่า <math>low[v]\,</math> ===
เราสามารถคำนวณค่า <math>low[v]\,</math> ระหว่างที่ทำ DFS ได้ โดยสังเกตว่าค่า <math>low[v]\,</math> เป็นค่าที่ต่ำที่สุดระหว่าง 
# <math>d[v]\,</math> 
# d[w] ถ้า <math>(v,w)\,</math> เป็น back edge และ 
# <math>low[u]\,</math> ถ้า <math>u\,</math> เป็นลูกของ <math>v\,</math>

Pseudocode ของ DFS ที่ทำการคำนวณ <math>low[v]\,</math> ไปด้วยมีดังนี้:

 function DFS(v)
 {
     time = time + 1
     d[v] = time
     visited[v] = true
     low[v] = d[v]
 
     for edge (v,w) ใดๆ
     {
         if w != parent[v] && visited[w] == true      // กรณีนี้เป็น back edge
             low[v] = min(low[v], d[w])
         else if visited[w] == false                  // กรณีนี้เป็น tree edge เส้นใหม่
         {
             parent[w] = v
             DFS(w)
             low[v] = min(low[v], low[w])
         } 
     }
 
     time = time + 1
     f[v] = time
 }

สังเกตว่าใน pseudocode ข้างบน เราจะเก็บไว้ด้วยว่าพ่อของแต่ละ vertex คืออะไร เพื่อแยกแยะระหว่าง tree edge กับ back edge

=== ตัดสินว่า vertex เป็น articulation point หรือไม่ ===
ทวนอีกครั้ง: vertex <math>v\,</math> จะเป็น articulation point ถ้าหากว่ามันมีลูก <math>u\,</math> ที่ไม่มี back edge ที่ไปต่อกับ vertex ที่อยู่สูงกว่า <math>v\,</math> ออกมาจาก subtree ที่มี root อยู่ที่ <math>u\,</math>

เขียนอีกแบบได้ว่า: vertex <math>v\,</math> จะเป็น articulation point ถ้าหากว่ามันมีลูก <math>u\,</math> ที่ <math>low[u] \geq d[v]\,</math>

เขียนเป็น pseudocode ได้ว่า:

 function is_articulation_point(v)
 {
    for edge (v,u) ใดๆ
        if parent[u] == v   // กล่าวคือ u เป็นลูกของ v
           if low[u] >= d[v]
               return true
    return false
 }

ฟังก์ชัน is_articulation_point(v) มี running time <math>O(\deg(v))\,</math> ดังนั้นถ้าเราถาม is_articulation_point สำหรับทุก vertex ในกราฟ เราจะใช้เวลา <math>O(|V| + |E|)\,</math>