เส้นทางที่ยาวที่สุดในต้นไม้ที่ไม่ได้ถูกส่งทิศทางด้วยการสำรวจเส้นทางเดียว

มีอัลกอริธึมมาตรฐานนี้สำหรับการค้นหาเส้นทางที่ยาวที่สุดในต้นไม้ที่ไม่ได้ใช้เส้นทางโดยใช้การค้นหาสองครั้งแรก:

• เริ่ม DFS จากจุดสุดยอดแบบสุ่มและหาจุดสุดยอดที่ไกลที่สุดจากมัน บอกว่ามันเป็นวี '$v$$v'$
• ตอนนี้เริ่ม DFS จากเพื่อค้นหาจุดสุดยอดจากนั้น เส้นทางนี้เป็นเส้นทางที่ยาวที่สุดในกราฟ$v'$

คำถามคือสิ่งนี้สามารถทำได้อย่างมีประสิทธิภาพมากขึ้น? เราสามารถทำได้ด้วย DFS หรือ BFS เดียวได้หรือไม่?

(สิ่งนี้สามารถอธิบายได้อย่างเท่าเทียมกันว่าเป็นปัญหาของการคำนวณเส้นผ่านศูนย์กลางของต้นไม้ที่ไม่ได้บอกทิศทาง)

เราทำการค้นหาในเชิงลึกครั้งแรกตามลำดับการโพสต์และผลลัพธ์โดยรวมนั่นคือเราแก้ปัญหาซ้ำ ๆ

สำหรับทุกโหนดมี children u 1 , … , u k (ในแผนผังการค้นหา) มีสองกรณี:$v$$u_1,\dots,u_k$

• เส้นทางที่ยาวที่สุดในโกหกในหนึ่งใน subtrees T U 1 , ... , T U k$T_v$$T_{u_1},\dots,T_{u_k}$
• เส้นทางที่ยาวที่สุดในมีโวลต์$T_v$$v$

$v$$H_{(k)} + H_{(k-1)} + 2$$k>1$$H_{(k)}+1$$k=1$$H = \{ h(T_{u_i}) \mid i=1,\dots,k\}$

ในโค้ดหลอกอัลกอริทึมจะมีลักษณะดังนี้:

procedure longestPathLength(T : Tree) = helper(T)[2]

/* Recursive helper function that returns (h,p)
 * where h is the height of T and p the length
 * of the longest path of T (its diameter) */
procedure helper(T : Tree) : (int, int) = {
  if ( T.children.isEmpty ) {
    return (0,0)
  }
  else {
    // Calculate heights and longest path lengths of children
    recursive = T.children.map { c => helper(c) }
    heights = recursive.map { p => p[1] }
    paths = recursive.map { p => p[2] }

    // Find the two largest subtree heights
    height1 = heights.max
    if (heights.length == 1) {
      height2 = -1
    } else {
      height2 = (heights.remove(height1)).max
    }

    // Determine length of longest path (see above)        
    longest = max(paths.max, height1 + height2 + 2)

    return (height1 + 1, longest)
  }
}

1. $A_{(k)}$$k$$A$

สิ่งนี้สามารถแก้ไขได้ในวิธีที่ดีกว่า นอกจากนี้เราสามารถลดความซับซ้อนของเวลาเป็น O (n) ด้วยการปรับเปลี่ยนเล็กน้อยในโครงสร้างข้อมูลและใช้วิธีการวนซ้ำ สำหรับการวิเคราะห์อย่างละเอียดและวิธีการแก้ไขปัญหานี้ด้วยโครงสร้างข้อมูลที่หลากหลาย

นี่คือบทสรุปของสิ่งที่ฉันต้องการอธิบายในบล็อกโพสต์ของฉัน :

วิธีการแบบเรียกซ้ำ - เส้นผ่าศูนย์กลางต้นไม้ อีกวิธีในการเข้าถึงปัญหานี้มีดังนี้ ดังที่เราได้กล่าวไปแล้วว่าเส้นผ่านศูนย์กลางสามารถ

1. อยู่ในต้นไม้ย่อยด้านซ้ายหรือ
2. อยู่ในต้นไม้ย่อยที่ถูกต้องหรือ
3. อาจแผ่ขยายไปทั่วรูต

ซึ่งหมายความว่าเส้นผ่านศูนย์กลางสามารถได้มาโดยอุดมคติ

1. เส้นผ่าศูนย์กลางของต้นไม้ด้านซ้ายหรือ
2. เส้นผ่าศูนย์กลางของต้นไม้ที่เหมาะสมหรือ
3. ความสูงของทรีย่อยด้านซ้าย + ความสูงของทรีย่อยด้านขวา + 1 (1 เพื่อเพิ่มโหนดรูทเมื่อเส้นผ่าศูนย์กลางขยายผ่านโหนดรูท)

และเรารู้ว่าเส้นผ่านศูนย์กลางเป็นเส้นทางที่ยาวที่สุดดังนั้นเราจึงใช้สูงสุด 1 และ 2 ในกรณีที่มันอยู่ข้างใดข้างหนึ่งหรือใช้เวลา 3 ถ้ามันแผ่ผ่านรูท

วิธีการทำซ้ำ - เส้นผ่าศูนย์กลางต้นไม้

เรามีแผนผังเราต้องการข้อมูลเมตากับแต่ละโหนดเพื่อให้แต่ละโหนดรู้ดังต่อไปนี้:

1. ความสูงของลูกซ้าย
2. ความสูงของลูกที่เหมาะสมและ
3. ระยะทางที่ไกลที่สุดระหว่างโหนดใบไม้

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

ตอนนี้เราต้องแก้ปัญหานี้ด้วยวิธีการจากล่างขึ้นบนเนื่องจากเราไม่มีความคิดเกี่ยวกับค่าสามค่าสำหรับรูท แต่เรารู้ค่าเหล่านี้สำหรับใบไม้

ขั้นตอนในการแก้ไข

1. เริ่มต้นใบทั้งหมดด้วยซ้ายความสูงและขวาความสูงเป็น 1
2. เริ่มต้นใบทั้งหมดด้วย maxDistance เป็น 0 เราทำให้มันเป็นจุดที่ถ้าซ้ายใดสูงหรือขวาสูงคือ 1 เราทำให้ maxDistance = 0
3. เลื่อนขึ้นหนึ่งครั้งและคำนวณค่าสำหรับพาเรนต์ทันที มันจะง่ายเพราะตอนนี้เรารู้ค่าเหล่านี้สำหรับเด็กแล้ว

4. ที่โหนดที่ระบุ

   • กำหนด leftHeight เป็นค่าสูงสุดของ (leftHeight หรือ rightHeight ของลูกซ้ายของมัน)
   • กำหนด rightHeight เป็นสูงสุดของ (leftHeight หรือ rightHeight ของลูกขวาของ)
   • ถ้าค่าใด ๆ เหล่านี้ (leftHeight หรือ rightHeight) เป็น 1 ให้ maxDistance เป็นศูนย์
   • ถ้าทั้งสองค่ามากกว่าศูนย์ให้ maxDistance เป็น leftHeight + rightHeight - 1
5. รักษา maxDistance ในตัวแปร temp และถ้าในขั้นตอนที่ 4 maxDistance นั้นมากกว่าค่าปัจจุบันของตัวแปรให้แทนที่ด้วยค่า maxDistance ใหม่
6. ในตอนท้ายของอัลกอริทึมค่าใน maxDistance คือเส้นผ่านศูนย์กลาง

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

 int getDiam(int root, vector<vector<int>>& adj_list, int& height, vector<int>& path, vector<int>& diam) {
    visited[root] = true;
    int m1 = -1;
    int m2 = -1;
    int max_diam = -1;
    vector<int> best1 = vector<int>();
    vector<int> best2 = vector<int>();
    vector<int> diam_path = vector<int>();
    for(auto n : adj_list[root]) {
        if(!visited[n]) {
            visited[n] = true;
            int _height = 0;
            vector<int> path1;
            vector<int> path2;
            int _diam = getDiam(n, adj_list, _height, path1, path2);
            if(_diam > max_diam) {
                max_diam = _diam;
                diam_path = path2;
            }
            if(_height > m1) {
                m2 = m1;
                m1 = _height;
                best2 = best1;
                best1 = path1;
            }
            else if(_height > m2) {
                m2 = _height;
                best2 = path1;
            }
        }
    }

    height = m1 + 1;

    path.insert( path.end(), best1.begin(), best1.end() );
    path.push_back(root);

    if(m1 + m2 + 2 > max_diam) {
        diam = path;
        std::reverse(best2.begin(), best2.end());
        diam.insert( diam.end(), best2.begin(), best2.end() );
    }
    else{
        diam = diam_path;
    }


    return max(m1 + m2 + 2, max_diam);
}