编程之美3.8：求二叉树节点的最大距离

最新推荐文章于 2024-10-01 18:52:56 发布

原创最新推荐文章于 2024-10-01 18:52:56 发布 · 757 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#编程之美 #动态规划

二叉树同时被 2 个专栏收录

4 篇文章

订阅专栏

动态规划

2 篇文章

订阅专栏

本文介绍了一种基于后序遍历的动态规划算法来解决多叉树中最长节点间距离的问题。通过定义节点间的两种距离值并递归计算，避免了深度优先遍历和直接枚举所有节点对的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本体是动态规划的思想求解。

下面的分析不局限于二叉树，而是以多叉树为例。

一棵树上距离最长的两个结点的可能情况有两种：

1.这两个节点位于根节点的同一棵子树上；

2.这两个节点位于根节点的两棵不同的子树上。

我的想法，不使用深度优先遍历，而是改用后序遍历多叉树，树的节点包含两个特殊值：root2node和node2node

struct ListNode {
    int val;
    int root2node; //以当前节点为根的子树上节点到根的最大距离 
    int node2node; //以当前结点尾根的子树的两个节点间最大距离 
    vector<ListNode*> child_list;
    ListNode(int val): val(val), root2node(0), node2node(0) {}
};

之后从根节点后序遍历多叉树，逐个完善每个节点的root2node和node2node值，当最后一个节点也就是根节点被处理完毕后，根节点的node2node值即为所求。

动态规划的思想体现在，每次计算根节点的root2node和node2node值时，不需要枚举树的每一对节点间距离，而是只需要依次访问一遍其孩子节点，即可有递推公式得出。

即：

当前节点的root2node=所有孩子节点的root2node的最大值+1

当前节点的node2node=max(当前节点最大的root2node+1 + 当前节点次大的root2node+1, 当前节点所有子树的node2node的最大值)

#include <iostream>
#include <vector>

using namespace std;

//这里使用了后序遍历，即先计算当前结点的所有孩子的root2node和node2node，之后再计算当前节点的这两个值 
//计算root时，先计算node2node 
struct ListNode {
    int val;
    int root2node; //以当前节点为根的子树上节点到根的最大距离 
    int node2node; //以当前结点尾根的子树的两个节点间最大距离 
    vector<ListNode*> child_list;
    ListNode(int val): val(val), root2node(0), node2node(0) {}
};

int max_num(int x, int y) {
    return x>y? x: y;
}

void cal(ListNode* root) {
    if (root==NULL || root->child_list.size()==0) {
        root->root2node = 0;
        root->node2node = 0;
    }
    else {
        int cur_max1 = 0;
        int cur_max2 = 0;
        int cur_max0 = 0; //单棵子树上的最大节点间距离中最大的 
        int temp;
        //下面的循环体现了动态规划的思想，不是枚举当前树所有的节点对，而是只需遍历一次当前节点的所有孩子 
        for (vector<ListNode*>::iterator iter = root->child_list.begin(); iter != root->child_list.end(); ++iter) {
            cal(*iter);
            temp = (*iter)->root2node + 1; //距离子树根节点的最长距离+1 
            if (temp > cur_max1) {
                cur_max2 = cur_max1;
                cur_max1 = temp;
            }
            else {
                if (temp > cur_max2) cur_max2 = temp;
            }
            temp = (*iter)->node2node; //这里不需要+1
            if (temp > cur_max0) cur_max0 = temp; 
        }
        //动态规划的递归公式 
        root->root2node = cur_max1; //该根节点到叶子节点的最大距离 
        root->node2node = max_num(cur_max1 + cur_max2, cur_max0); //以该节点为根的子树的两个节点的最大距离 
    
    }
}

int main() {
    ListNode* h = new ListNode(0);
    ListNode* p1 = new ListNode(1); h->child_list.push_back(p1);
    ListNode* p2 = new ListNode(2); h->child_list.push_back(p2);
    ListNode* p3 = new ListNode(3); h->child_list.push_back(p3);
    ListNode* p4 = new ListNode(4); p1->child_list.push_back(p4);
    ListNode* p5 = new ListNode(5); p1->child_list.push_back(p5);
    ListNode* p6 = new ListNode(6); p4->child_list.push_back(p6);
    ListNode* p7 = new ListNode(7); p5->child_list.push_back(p7);
    ListNode* p8 = new ListNode(8); p6->child_list.push_back(p8);
    ListNode* p9 = new ListNode(9); p7->child_list.push_back(p9);
    ListNode* p10 = new ListNode(10); p7->child_list.push_back(p10);
    //ListNode* p11 = new ListNode(11); p2->child_list.push_back(p11);
    //ListNode* p12 = new ListNode(12); p7->child_list.push_back(p12);
    
    cal(h);
    cout << (h->node2node) << endl;
    
    system("pause");
    return 1;
}