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

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

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

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

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;
}