[hihocoder1050]树中的最长路

最新推荐文章于 2018-03-19 20:39:20 发布

原创最新推荐文章于 2018-03-19 20:39:20 发布 · 392 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#hihocoder #最长路径

hihocoder 专栏收录该内容

22 篇文章

订阅专栏

本文介绍了一种使用递归算法来寻找树中最长路径的方法。通过设定全局根节点，并计算以任意节点为根的子树中的最长路径及深度。算法避免了形成回路的情况，并通过优化比较过程减少了平均时间。

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

问题简介

寻找树中的最长路，详情请参考 hihocoder官网。

算法详解

使用递归算法实现，首先设定一个全局根节点（这里使用编号为1的节点），然后任意节点计算以该节点为根节点的子树中的最长路径以及深度。

使用longest_path(int &lt,int &ld)实现上诉功能，lt用于返回最长路径，ld返回深度。对于任意节点，该节点的最长路径为子节点的最长路径的最大值，在与所有子节点中深度的第一最大与第二最大值的和比较，取最大。最大深度则是所有子节点的最大深度+1。

算法中求前两个最大值的时候，每次先与第二最大值比较，可以减少平均时间。

注意去除子节点到父亲节点的边，否则会形成回路，无限循环。

num没有实际作用，只是用于标记节点，便于debug。

全部代码

#include <iostream>
#include <list>

using namespace std;

struct Node{
    static int cnt;
    int num;
    list<Node*> next;

    Node():num(cnt++) {}
    Node(const Node &n):num(n.num),next(n.next) {}
    ~Node() {}

    void longest_path(int <,int &ld){
        if (next.size() == 0) {
            ld = lt = 0;
//            cout << num << ": " << lt << ' ' << ld << endl;
            return;
        }
        int tmp_ld,tmp_lt;
        if (next.size() == 1) {
            (*(next.begin()))->next.remove(this);
            (*(next.begin()))->longest_path(tmp_lt,tmp_ld);
            ld = tmp_ld + 1;
            lt = max(tmp_lt,ld);
//            cout << num << ": " << lt << ' ' << ld << endl;
            return;
        }
        list<Node*>::iterator iter = next.begin();
        (*iter)->next.remove(this);
        (*iter)->longest_path(tmp_lt,tmp_ld);
        int max_ld1 = tmp_ld+1,max_lt = tmp_lt;

        ++iter;
        (*iter)->next.remove(this);
        (*iter)->longest_path(tmp_lt,tmp_ld);
        int max_ld2 = tmp_ld+1;
        max_lt = max(max_lt,tmp_lt);

        if (max_ld1 < max_ld2)
            swap(max_ld1,max_ld2);

        ++iter;

        for (;iter != next.end();++iter){
            (*iter)->next.remove(this);
            (*iter)->longest_path(tmp_lt,tmp_ld);
            if (tmp_lt > max_lt)
                max_lt = tmp_lt;
            if (tmp_ld+1 > max_ld2){
                max_ld2 = tmp_ld+1;
                if (max_ld2 > max_ld1)
                    swap(max_ld1,max_ld2);
            }
        }

        ld = max_ld1;
        lt = max(max_lt,max_ld1+max_ld2);

//        cout << num << ": " << lt << ' ' << ld << endl;
    }
};

int Node::cnt = 0;
Node nodes[100000];

int main()
{
    int N,A,B;
    cin >> N;
    for (int i = 0;i < N-1;++i){
        cin >> A >> B;
        nodes[A-1].next.push_back(nodes+B-1);
        nodes[B-1].next.push_back(nodes+A-1);
    }

    int lt,ld;
    nodes[0].longest_path(lt,ld);
    cout << lt << endl;
    return 0;
}