ฉันเข้าใจความแตกต่างระหว่าง DFS และ BFS แต่ฉันสนใจที่จะรู้ว่ามันใช้งานได้ดีกว่ากันหรือไม่?

ใครช่วยยกตัวอย่างของวิธีการที่ DFS จะกล้าหาญ BFS และในทางกลับกัน?

ซึ่งขึ้นอยู่กับโครงสร้างของแผนผังการค้นหาและจำนวนและตำแหน่งของโซลูชัน (หรือรายการที่ค้นหาสำหรับการค้นหา)

• หากคุณรู้ว่าวิธีแก้ปัญหาอยู่ไม่ไกลจากรากของทรีการค้นหาแบบกว้าง (BFS) อาจดีกว่า

• หากแผนผังมีความลึกมากและโซลูชันหายากการค้นหาความลึกครั้งแรก (DFS) อาจใช้เวลานานมาก แต่ BFS อาจเร็วขึ้น

• หากแผนผังกว้างมาก BFS อาจต้องการหน่วยความจำมากเกินไปดังนั้นจึงอาจไม่สามารถใช้งานได้อย่างสมบูรณ์

• หากการแก้ปัญหาเป็นประจำ แต่อยู่ลึกลงไปในทรี BFS อาจเป็นไปไม่ได้

• หากโครงสร้างการค้นหาลึกมากคุณจะต้อง จำกัด ความลึกของการค้นหาสำหรับการค้นหาความลึกครั้งแรก (DFS) อย่างไรก็ตาม (เช่นการทำซ้ำลึกลงไป)

แต่นี่เป็นเพียงกฎของหัวแม่มือ คุณอาจต้องทำการทดสอบ

ค้นหาความลึกครั้งแรก

การค้นหาความลึกครั้งแรกมักใช้ในการจำลองเกม (และสถานการณ์ที่เหมือนเกมในโลกแห่งความเป็นจริง) ในเกมทั่วไปคุณสามารถเลือกหนึ่งในการกระทำที่เป็นไปได้หลายอย่าง แต่ละตัวเลือกนำไปสู่การเลือกเพิ่มเติมซึ่งแต่ละทางเลือกนำไปสู่การเลือกเพิ่มเติมและอื่น ๆ ลงในกราฟของความเป็นไปได้รูปต้นไม้

ตัวอย่างเช่นในเกมเช่นหมากรุกทิคแทคเมื่อคุณตัดสินใจว่าจะทำอะไรคุณสามารถจินตนาการถึงการเคลื่อนไหวจากนั้นตอบโต้ฝ่ายตรงข้ามที่เป็นไปได้ของคุณ คุณสามารถตัดสินใจว่าจะทำอย่างไรโดยดูว่าการเคลื่อนไหวใดที่นำไปสู่ผลลัพธ์ที่ดีที่สุด

เส้นทางบางเส้นทางในทรีเกมเท่านั้นที่จะนำไปสู่ชัยชนะของคุณ บางคนนำไปสู่ชัยชนะโดยคู่ต่อสู้ของคุณเมื่อคุณไปถึงจุดสิ้นสุดคุณต้องสำรองข้อมูลหรือย้อนกลับไปยังโหนดก่อนหน้าและลองเส้นทางอื่น ด้วยวิธีนี้คุณสำรวจต้นไม้จนกว่าคุณจะพบเส้นทางที่มีข้อสรุปที่ประสบความสำเร็จ จากนั้นคุณทำการย้ายครั้งแรกไปตามเส้นทางนี้

ค้นหาความกว้างแรก

การค้นหาความกว้างแรกมีคุณสมบัติที่น่าสนใจ: ก่อนอื่นจะค้นหาจุดยอดทั้งหมดที่อยู่ห่างจากจุดเริ่มต้นหนึ่งจุดจากนั้นจุดยอดทั้งหมดที่อยู่ห่างออกไปสองขอบและอื่น ๆ สิ่งนี้มีประโยชน์หากคุณกำลังพยายามหาเส้นทางที่สั้นที่สุดจากจุดเริ่มต้นไปยังจุดสุดยอดที่กำหนด คุณเริ่มต้น BFS และเมื่อคุณค้นหาจุดสุดยอดที่ระบุคุณรู้เส้นทางที่คุณติดตามจนเป็นเส้นทางที่สั้นที่สุดไปยังโหนด หากมีเส้นทางที่สั้นกว่า BFS จะได้พบมันแล้ว

การค้นหาแบบกว้างสามารถใช้ในการค้นหาโหนดเพื่อนบ้านในเครือข่ายเพียร์ทูเพียร์เช่น BitTorrent ระบบ GPS เพื่อค้นหาสถานที่ใกล้เคียงไซต์เครือข่ายสังคมออนไลน์เพื่อค้นหาผู้คนในระยะทางที่กำหนดและสิ่งต่าง ๆ เช่นนั้น

คำอธิบายที่ดีจาก http://www.programmerinterview.com/index.php/data-structures/dfs-vs-bfs/

ตัวอย่างของ BFS

นี่คือตัวอย่างของลักษณะ BFS นี่คือสิ่งที่เหมือน Traversal ทรีสั่งซื้อระดับที่เราจะใช้ QUEUE ด้วยวิธีการวนซ้ำ (การเรียกซ้ำส่วนใหญ่จะจบลงด้วย DFS) หมายเลขแสดงลำดับที่โหนดถูกเข้าถึงใน BFS:

ในการค้นหาความลึกครั้งแรกคุณเริ่มต้นที่รูทและติดตามหนึ่งในกิ่งของต้นไม้มากที่สุดเท่าที่จะทำได้จนกว่าจะพบโหนดที่คุณกำลังค้นหาหรือคุณกดโหนดลีฟ (โหนดที่ไม่มีลูก) หากคุณกดปุ่มใบไม้คุณจะค้นหาต่อจากบรรพบุรุษที่อยู่ใกล้ที่สุดโดยใช้ลูกที่ยังไม่ได้สำรวจ

ตัวอย่างของ DFS

นี่คือตัวอย่างของลักษณะ DFS ฉันคิดว่าการสำรวจเส้นทางโพสต์ในไบนารีต้นไม้จะเริ่มทำงานจากระดับ Leaf ก่อน ตัวเลขแสดงถึงลำดับที่เข้าถึงโหนดใน DFS:

ความแตกต่างระหว่าง DFS และ BFS

การเปรียบเทียบ BFS และ DFS ข้อดีของ DFS คือมีความต้องการหน่วยความจำต่ำกว่า BFS มากเพราะไม่จำเป็นต้องเก็บพอยน์เตอร์พอยน์เตอร์ทั้งหมดในแต่ละระดับ ขึ้นอยู่กับข้อมูลและสิ่งที่คุณกำลังมองหา DFS หรือ BFS อาจมีประโยชน์

ตัวอย่างเช่นให้ต้นไม้ครอบครัวหากมีใครบางคนกำลังมองหาใครบางคนบนต้นไม้ที่ยังมีชีวิตอยู่มันจะปลอดภัยที่จะคิดว่าบุคคลนั้นจะอยู่ที่ด้านล่างของต้นไม้ ซึ่งหมายความว่า BFS จะใช้เวลานานมากในการเข้าถึงระดับสุดท้าย อย่างไรก็ตาม DFS จะค้นหาเป้าหมายได้เร็วขึ้น แต่ถ้ามีใครกำลังมองหาสมาชิกในครอบครัวที่เสียชีวิตไปนานมากแล้วบุคคลนั้นจะอยู่ใกล้กับด้านบนของต้นไม้ จากนั้น BFS มักจะเร็วกว่า DFS ดังนั้นข้อดีของการเปลี่ยนแปลงอาจแตกต่างกันไปขึ้นอยู่กับข้อมูลและสิ่งที่คุณกำลังมองหา

อีกตัวอย่างหนึ่งคือ Facebook; ข้อเสนอแนะเกี่ยวกับเพื่อนของเพื่อน เราต้องการเพื่อนในทันทีสำหรับข้อเสนอแนะที่เราสามารถใช้ BFS อาจเป็นการค้นหาเส้นทางที่สั้นที่สุดหรือตรวจจับรอบ (โดยใช้การเรียกซ้ำ) เราสามารถใช้ DFS

การค้นหาครั้งแรกโดยทั่วไปเป็นวิธีที่ดีที่สุดเมื่อความลึกของต้นไม้แตกต่างกันไปและคุณต้องการค้นหาวิธีการแก้ปัญหาเป็นส่วนหนึ่งเท่านั้น ตัวอย่างเช่นการค้นหาพา ธ ที่สั้นที่สุดจากค่าเริ่มต้นไปยังค่าสุดท้ายเป็นที่ที่ดีในการใช้ BFS

การค้นหาความลึกแรกมักใช้เมื่อคุณต้องการค้นหาทั้งแผนผัง ง่ายกว่าในการนำไปใช้ (ใช้การเรียกซ้ำ) กว่า BFS และต้องการสถานะที่น้อยกว่า: ในขณะที่ BFS ต้องการให้คุณเก็บ 'frontier' ทั้งหมด DFS ต้องการเพียงคุณเก็บรายการของโหนดหลักขององค์ประกอบปัจจุบัน

DFS นั้นมีประสิทธิภาพด้านพื้นที่มากกว่า BFS แต่อาจมีความลึกที่ไม่จำเป็น

ชื่อของพวกเขาเปิดเผย: หากมีความกว้างมาก (เช่นปัจจัยการแตกแขนงใหญ่) แต่ความลึกที่ จำกัด มาก (เช่นจำนวน "การเคลื่อนไหว" ที่ จำกัด ) ดังนั้น DFS จึงเป็นที่นิยมมากกว่า BFS

บน IDDFS

มันควรจะกล่าวว่ามีตัวแปรที่ไม่เป็นที่รู้จักซึ่งรวมประสิทธิภาพพื้นที่ของ DFS แต่ (cummulatively) การเยี่ยมชมตามลำดับระดับของ BFS คือการค้นหาเชิงลึกขั้นแรกซ้ำ ๆ อัลกอริทึมนี้กลับมาเยือนบางโหนด แต่มันก็มีส่วนทำให้ปัจจัยคงที่ของความแตกต่างเชิงซีมโทติคเท่านั้น

เมื่อคุณเข้าหาคำถามนี้ในฐานะโปรแกรมเมอร์ปัจจัยหนึ่งที่โดดเด่น: ถ้าคุณใช้การเรียกซ้ำการค้นหาเชิงลึกครั้งแรกนั้นง่ายกว่าที่จะนำมาใช้เพราะคุณไม่จำเป็นต้องบำรุงรักษาโครงสร้างข้อมูลเพิ่มเติมที่มีโหนดที่ยังสำรวจอยู่

ต่อไปนี้เป็นการค้นหากราฟที่ไม่เกี่ยวข้องหากคุณเก็บข้อมูล“ เยี่ยมชมแล้ว” ไว้ในโหนด:

def dfs(origin):                               # DFS from origin:
    origin.visited = True                      # Mark the origin as visited
    for neighbor in origin.neighbors:          # Loop over the neighbors
        if not neighbor.visited: dfs(next)     # Visit each neighbor if not already visited

หากการจัดเก็บข้อมูล“ เยี่ยมชมแล้ว” ในโครงสร้างข้อมูลแยกต่างหาก:

def dfs(node, visited):                        # DFS from origin, with already-visited set:
    visited.add(node)                          # Mark the origin as visited
    for neighbor in node.neighbors:            # Loop over the neighbors
        if not neighbor in visited:            # If the neighbor hasn't been visited yet,
            dfs(node, visited)                 # then visit the neighbor
dfs(origin, set())

เปรียบเทียบสิ่งนี้กับการค้นหาแบบกว้างซึ่งคุณจำเป็นต้องรักษาโครงสร้างข้อมูลแยกต่างหากสำหรับรายการของโหนดที่ยังไม่ได้ไปเยี่ยมไม่ว่าจะเกิดอะไรขึ้น

ข้อได้เปรียบที่สำคัญอย่างหนึ่งของ BFS ก็คือมันสามารถใช้ในการค้นหาเส้นทางที่สั้นที่สุดระหว่างสองโหนดในกราฟที่ไม่ถ่วง ในขณะที่เราไม่สามารถใช้ DFS สำหรับสิ่งเดียวกันได้

สำหรับ BFS เราสามารถพิจารณาตัวอย่าง Facebook เราได้รับคำแนะนำในการเพิ่มเพื่อนจากโปรไฟล์ FB จากโปรไฟล์เพื่อนคนอื่น ๆ สมมติว่า A-> B ในขณะที่ B-> E และ B-> F ดังนั้น A จะได้รับคำแนะนำสำหรับ E และ F พวกเขาจะต้องใช้ BFS เพื่ออ่านจนถึงระดับที่สอง DFS ขึ้นอยู่กับสถานการณ์ที่เราต้องการคาดการณ์บางอย่างจากข้อมูลที่เรามีจากต้นทางไปยังปลายทาง ดังกล่าวแล้วเกี่ยวกับหมากรุกหรือซูโดกุ เมื่อสิ่งที่ฉันมีแตกต่างกันที่นี่คือฉันเชื่อว่าควรใช้ DFS สำหรับเส้นทางที่สั้นที่สุดเพราะ DFS จะครอบคลุมเส้นทางทั้งหมดก่อนจากนั้นเราสามารถตัดสินใจได้ดีที่สุด แต่ในฐานะที่เป็น BFS จะใช้วิธีการโลภดังนั้นอาจดูเหมือนว่าเส้นทางที่สั้นที่สุด แต่ผลลัพธ์สุดท้ายอาจแตกต่างกัน แจ้งให้เราทราบว่าความเข้าใจของฉันผิดหรือเปล่า

อัลกอริทึมบางอย่างขึ้นอยู่กับคุณสมบัติเฉพาะของ DFS (หรือ BFS) ในการทำงาน ตัวอย่างเช่นอัลกอริทึม Hopcroft และ Tarjan สำหรับการค้นหาส่วนประกอบที่เชื่อมต่อ 2 ใช้ประโยชน์จากข้อเท็จจริงที่ว่าแต่ละโหนดที่เยี่ยมชมแล้วพบโดย DFS อยู่บนเส้นทางจากรากไปยังโหนดสำรวจในปัจจุบัน

ต่อไปนี้เป็นคำตอบที่ครอบคลุมถึงสิ่งที่คุณถาม

ในแง่ง่าย ๆ :

อัลกอริทึม Breadth First Search (BFS) จากชื่อ "Breadth" ค้นพบเพื่อนบ้านทั้งหมดของโหนดผ่านขอบนอกของโหนดจากนั้นจะค้นพบเพื่อนบ้านที่ไม่ได้เข้าเยี่ยมชมของเพื่อนบ้านที่กล่าวถึงก่อนหน้านี้ผ่านขอบนอกและอื่น ๆ จนกระทั่งทั้งหมด โหนดที่สามารถเข้าถึงได้จากแหล่งที่มาดั้งเดิมถูกเยี่ยมชม (เราสามารถดำเนินการต่อและรับแหล่งที่มาแบบดั้งเดิมอื่นได้หากยังมีโหนดที่ไม่ได้รับการเข้าชมและอื่น ๆ ) นั่นเป็นเหตุผลว่าทำไมจึงสามารถใช้เพื่อค้นหาเส้นทางที่สั้นที่สุด (ถ้ามี) จากโหนด (แหล่งกำเนิดดั้งเดิม) ไปยังโหนดอื่นหากน้ำหนักของขอบเท่ากัน

อัลกอริธึมการค้นหาความลึกแรก (DFS) จากชื่อ "ความลึก" ค้นพบเพื่อนบ้านที่ไม่ได้รับการเข้าชมของโหนด x ที่ค้นพบล่าสุดผ่านขอบนอก หากไม่มีเพื่อนบ้านที่ไม่ได้เข้าชมจากโหนด x จะมีการย้อนรอยอัลกอริทึมเพื่อค้นหาเพื่อนบ้านที่ไม่ได้รับสิทธิ์ของโหนด (ผ่านขอบด้านนอก) ซึ่งโหนดนั้นถูกค้นพบและจากจุดนั้นเป็นต้นไปจนกว่าโหนดทั้งหมดที่เข้าถึงได้จากแหล่งกำเนิดดั้งเดิม (เราสามารถดำเนินการต่อและรับแหล่งกำเนิดอื่นหากยังมีโหนดที่ไม่ได้เข้าชมและยังคงมีอยู่)

ทั้ง BFS และ DFS อาจไม่สมบูรณ์ ตัวอย่างเช่นหากปัจจัยการแตกสาขาของโหนดไม่มีที่สิ้นสุดหรือใหญ่มากสำหรับทรัพยากร (หน่วยความจำ) ที่จะสนับสนุน (เช่นเมื่อจัดเก็บโหนดที่จะค้นพบถัดไป) ดังนั้น BFS จะไม่สมบูรณ์แม้ว่าคีย์การค้นหาจะอยู่ในระยะไกล ของขอบไม่กี่จากแหล่งกำเนิด ปัจจัยการแตกสาขาที่ไม่มีที่สิ้นสุดนี้อาจเป็นเพราะตัวเลือกที่ไม่มีที่สิ้นสุด (โหนดใกล้เคียง) จากโหนดที่ระบุเพื่อค้นหา หากความลึกไม่ จำกัด หรือใหญ่มากสำหรับทรัพยากร (หน่วยความจำ) ที่จะรองรับ (เช่นเมื่อจัดเก็บโหนดที่จะค้นพบถัดไป) DFS จะไม่สมบูรณ์แม้ว่าคีย์ค้นหาจะเป็นเพื่อนบ้านที่สามของแหล่งกำเนิด ความลึกที่ไม่มีที่สิ้นสุดนี้อาจเป็นเพราะสถานการณ์ที่มีสำหรับทุกโหนดที่อัลกอริทึมค้นพบอย่างน้อยก็เป็นทางเลือกใหม่

ดังนั้นเราสามารถสรุปได้ว่าเมื่อใดควรใช้ BFS และ DFS สมมติว่าเรากำลังเผชิญกับปัจจัย จำกัด สาขาที่จัดการได้และความลึกที่ จำกัด ที่จัดการได้ หากโหนดที่สืบค้นนั้นตื้นสามารถเข้าถึงได้หลังจากขอบบางอันจากแหล่งกำเนิดนั้นจะดีกว่าถ้าใช้ BFS ในทางกลับกันถ้าโหนดการค้นหาลึกเช่นเข้าถึงได้หลังจากขอบจำนวนมากจากแหล่งกำเนิดแล้วมันจะดีกว่าที่จะใช้ DFS

ตัวอย่างเช่นในเครือข่ายสังคมหากเราต้องการค้นหาคนที่มีความสนใจคล้ายกันกับบุคคลที่เฉพาะเจาะจงเราสามารถใช้ BFS จากบุคคลนี้เป็นแหล่งกำเนิดเพราะคนเหล่านี้ส่วนใหญ่จะเป็นเพื่อนโดยตรงหรือเพื่อนของเพื่อนเช่น หรือสองขอบไกล ในทางตรงกันข้ามถ้าเราต้องการค้นหาคนที่มีความสนใจแตกต่างกันโดยสิ้นเชิงของบุคคลใดบุคคลหนึ่งเราสามารถใช้ DFS จากบุคคลนี้เป็นแหล่งกำเนิดเพราะคนเหล่านี้ส่วนใหญ่จะอยู่ห่างจากเขามากเช่นเพื่อนของเพื่อน .... คือมีขอบมากเกินไป

แอปพลิเคชันของ BFS และ DFS อาจแตกต่างกันไปเนื่องจากกลไกการค้นหาในแต่ละรายการ ตัวอย่างเช่นเราสามารถใช้ BFS อย่างใดอย่างหนึ่ง (สมมติว่าปัจจัยการแตกแขนงสามารถจัดการได้) หรือ DFS (สมมติว่าระดับความลึกนั้นสามารถจัดการได้) เมื่อเราต้องการตรวจสอบความสามารถในการเข้าถึงจากโหนดหนึ่งไปยังอีกโหนดหนึ่ง นอกจากนี้ทั้งสองยังสามารถแก้ไขงานเดียวกันเช่นการจัดเรียงทอพอโลยีของกราฟ (ถ้ามี) BFS สามารถใช้ในการค้นหาเส้นทางที่สั้นที่สุดที่มีขอบน้ำหนักหน่วยจากโหนด (แหล่งที่มาดั้งเดิม) ไปยังอีก ในขณะที่ DFS สามารถใช้เพื่อหมดทางเลือกทั้งหมดเนื่องจากลักษณะของความลึกเช่นการค้นหาเส้นทางที่ยาวที่สุดระหว่างสองโหนดในกราฟแบบวนรอบ นอกจากนี้ยังสามารถใช้ DFS สำหรับการตรวจสอบวงจรในกราฟ

ในท้ายที่สุดถ้าเรามีความลึกไม่ จำกัด และปัจจัยการแตกแขนงเราสามารถใช้ Iterative Deepening Search (IDS)

ตามคุณสมบัติของ DFS และ BFS ตัวอย่างเช่นเมื่อเราต้องการหาเส้นทางที่สั้นที่สุด เรามักจะใช้ bfs ก็สามารถรับประกัน 'สั้นที่สุด' แต่ dfs เท่านั้นสามารถรับประกันได้ว่าเราสามารถมาจากจุดนี้สามารถบรรลุจุดนั้นไม่สามารถรับประกัน 'สั้นที่สุด'

ฉันคิดว่ามันขึ้นอยู่กับปัญหาที่คุณเผชิญ

1. เส้นทางที่สั้นที่สุดบนกราฟอย่างง่าย -> bfs
2. ผลลัพธ์ที่เป็นไปได้ทั้งหมด -> dfs
3. ค้นหาบนกราฟ (รักษาต้นไม้ martix เป็นกราฟด้วย) -> dfs ....

เนื่องจากการค้นหาความลึกครั้งแรกใช้สแต็กเป็นโหนดที่ถูกประมวลผลการ backtracking นั้นมาพร้อมกับ DFS เนื่องจากการค้นหาความกว้างแรกใช้คิวไม่ใช่สแต็กเพื่อติดตามว่าโหนดใดที่ถูกประมวลผลการย้อนรอยจึงไม่ได้มาพร้อมกับ BFS

เมื่อความกว้างของต้นไม้มีขนาดใหญ่มากและความลึกน้อยใช้ DFS เนื่องจากกองการเรียกซ้ำจะไม่ล้นใช้ BFS เมื่อความกว้างต่ำและความลึกมีขนาดใหญ่มากในการสำรวจต้นไม้

นี่เป็นตัวอย่างที่ดีในการแสดงให้เห็นว่า BFS ดีกว่า DFS ในบางกรณี https://leetcode.com/problems/01-matrix/

เมื่อดำเนินการอย่างถูกต้องทั้งสองวิธีควรเข้าชมเซลล์ที่มีระยะทางไกลกว่าเซลล์ปัจจุบัน +1 แต่ DFS ไม่มีประสิทธิภาพและเข้าชมเซลล์เดียวกันซ้ำ ๆ ทำให้เกิดความซับซ้อน O (n * n)

ตัวอย่างเช่น,

1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1, 
1,1,1,1,1,1,1,1, 
0,0,0,0,0,0,0,0,

ขึ้นอยู่กับสถานการณ์ที่ใช้เมื่อใดก็ตามที่เรามีปัญหาในการข้ามกราฟเราทำเพื่อจุดประสงค์บางอย่าง เมื่อมีปัญหาในการค้นหาเส้นทางที่สั้นที่สุดในกราฟที่ไม่มีน้ำหนักหรือการค้นหาว่ากราฟเป็น bipartite หรือไม่เราสามารถใช้ BFS ได้ สำหรับปัญหาของการตรวจจับรอบหรือตรรกะใด ๆ ที่ต้องใช้การย้อนรอยเราสามารถใช้ DFS