📜  树上的动态编程套装2

📅  最后修改于: 2021-04-17 11:26:04             🧑  作者: Mango

给定一棵具有N个节点和N-1个边的树,树中的任何节点被视为树的根时,找出最大高度

上图表示一棵具有11个节点10条边的树,以及当将节点1视为根时给出最大高度的路径。最大高度为3。

在上图中,当将2视为根时,找到的最长路径是红色。天真的方法是使用DFS遍历每个节点遍历树,并在将节点视为树的根节点时计算最大高度。遍历树的DFS的时间复杂度为O(N)。所有N个节点的DFS的总时间复杂度将为O(N)* N,即O(N 2 )
通过使用“树上动态编程”可以解决上述问题要解决此问题,请为每个节点预先计算两件事。一个最大的高度是通过树枝向下延伸到树叶时的最大高度。而另一个则是通过其父级向上移动到任何叶子时的最大高度。
最佳子结构:
当节点i被视为根节点时,
in [i]是当我们通过其子树和树叶向下行驶时的最大树高。
同样, out [i]是通过父树向上行驶时树的最大高度。

in [i]的计算:

在上图中,已经为每个节点i计算了in [i]的值。取每个子树的最大值,并将其加1到该子树的父树。在父树和子树之间的边缘加1。使用DFS遍历树,并为每个节点将in [i]计算为max(in [i],1 + in [child])
out [i]的计算:

上图显示了所有out [i]值和路径。为了计算out [i],向上移动到节点i的父节点。从节点i的父节点开始,有两种移动方法,一种将在父节点的所有分支中。另一个方向是移动到节点i的父节点(称为parent1)的父节点(称为parent2以避免混淆)。通过parent2向上的最大高度本身是out [parent1] 。通常,out [node i]为1 + max(out [i],所有分支的1 + max)。在节点和父节点之间的边缘加1。

上图说明了将2视为树的根时out [i]的计算。由于已经计算出通过该路径的最大高度并将其存储在i [2]中,因此不计入节点2的分支。向上移动,在这种情况下,2的父级(即1)没有父级。因此,在计算最大值时会考虑除具有该节点的分支以外的分支。

上图说明了out [10]的计算。节点10的父节点(即7)具有一个父节点和一个分支(在这种情况下,恰好是一个子节点)。因此,在存在父级和分支的情况下,将两者的最大高度都计算在内。
如果父级有多个分支,则取其中最长的一个进行计数(不包括该节点所在的分支)
计算连接到父级的所有分支的最大高度:
in [i]存储向下移动时的最大高度。无需存储所有长度的分支。所有分支中只有第一和第二最大长度会给出答案。由于所使用的算法基于DFS,因此将考虑连接到父级的所有分支,包括具有节点的分支。如果由此获得的第一条最大路径与in [i]相同,则maximum1是节点i所在分支的长度。在这种情况下,我们的最长路径将为max2。
in [i]和out [i]的递归关系:

下面是上述想法的实现:

C++
// C++ code to find the maximum path length
// considering any node as root
#include 
using namespace std;
const int MAX_NODES = 100;
  
int in[MAX_NODES];
int out[MAX_NODES];
  
// function to pre-calculate the array in[]
// which stores the maximum height when travelled
// via branches
void dfs1(vector v[], int u, int parent)
{
    // initially every node has 0 height
    in[u] = 0;
  
    // traverse in the subtree of u
    for (int child : v[u]) {
  
        // if child is same as parent
        if (child == parent)
            continue;
  
        // dfs called
        dfs1(v, child, u);
  
        // recursively calculate the max height
        in[u] = max(in[u], 1 + in[child]);
    }
}
  
// function to pre-calculate the array ouut[]
// which stores the maximum height when traveled
// via parent
void dfs2(vector v[], int u, int parent)
{
    // stores the longest and second 
    // longest branches
    int mx1 = -1, mx2 = -1;
  
    // traverse in the subtress of u
    for (int child : v[u]) {
        if (child == parent)
            continue;
  
        // compare and store the longest
        // and second longest
        if (in[child] >= mx1) {
            mx2 = mx1;
            mx1 = in[child];
        }
  
        else if (in[child] > mx2)
            mx2 = in[child];
    }
  
    // traverse in the subtree of u
    for (int child : v[u]) {
        if (child == parent)
            continue;
  
        int longest = mx1;
  
        // if longest branch has the node, then
        // consider the second longest branch
        if (mx1 == in[child])
            longest = mx2;
  
        // recursively calculate out[i]
        out[child] = 1 + max(out[u], 1 + longest);
  
        // dfs function call
        dfs2(v, child, u);
    }
}
  
// function to print all the maximum heights
// from every node
void printHeights(vector v[], int n)
{
    // traversal to calculate in[] array
    dfs1(v, 1, 0);
  
    // traversal to calculate out[] array
    dfs2(v, 1, 0);
  
    // print all maximum heights
    for (int i = 1; i <= n; i++)
        cout << "The maximum height when node " 
             << i << " is considered as root"
             << " is " << max(in[i], out[i]) 
             << "\n";
}
  
// Driver Code
int main()
{
    int n = 11;
    vector v[n + 1];
  
    // initialize the tree given in the diagram
    v[1].push_back(2), v[2].push_back(1);
    v[1].push_back(3), v[3].push_back(1);
    v[1].push_back(4), v[4].push_back(1);
    v[2].push_back(5), v[5].push_back(2);
    v[2].push_back(6), v[6].push_back(2);
    v[3].push_back(7), v[7].push_back(3);
    v[7].push_back(10), v[10].push_back(7);
    v[7].push_back(11), v[11].push_back(7);
    v[4].push_back(8), v[8].push_back(4);
    v[4].push_back(9), v[9].push_back(4);
  
    // function to print the maximum height from every node
    printHeights(v, n);
  
    return 0;
}


Java
// Java code to find the maximum path length
// considering any node as root
import java.io.*;
import java.util.*;
  
class GFG{
  
static final int MAX_NODES = 100;
static int in[] = new int[MAX_NODES];
static int out[] = new int[MAX_NODES];
  
// Function to pre-calculate the array in[]
// which stores the maximum height when travelled
// via branches
static void dfs1(ArrayList> v,
                 int u, int parent)
{
      
    // Initially every node has 0 height
    in[u] = 0;
  
    // Traverse in the subtree of u
    for(int j = 0; j < v.get(u).size(); j++) 
    {
        int child = v.get(u).get(j);
          
        // If child is same as parent
        if (child == parent)
            continue;
  
        // dfs called
        dfs1(v, child, u);
  
        // Recursively calculate the max height
        in[u] = Math.max(in[u], 1 + in[child]);
    }
}
  
// Function to pre-calculate the array ouut[]
// which stores the maximum height when traveled
// via parent
static void dfs2(ArrayList> v,
                 int u, int parent)
{
      
    // Stores the longest and second
    // longest branches
    int mx1 = -1, mx2 = -1;
  
    // Traverse in the subtress of u
    for(int j = 0; j < v.get(u).size(); j++)
    {
        int child = v.get(u).get(j);
        if (child == parent)
            continue;
  
        // Compare and store the longest
        // and second longest
        if (in[child] >= mx1) 
        {
            mx2 = mx1;
            mx1 = in[child];
        }
  
        else if (in[child] > mx2)
            mx2 = in[child];
    }
  
    // Traverse in the subtree of u
    for(int j = 0; j < v.get(u).size(); j++)
    {
        int child = v.get(u).get(j);
        if (child == parent)
            continue;
  
        int longest = mx1;
  
        // If longest branch has the node, then
        // consider the second longest branch
        if (mx1 == in[child])
            longest = mx2;
  
        // Recursively calculate out[i]
        out[child] = 1 + Math.max(out[u], 1 + longest);
  
        // dfs function call
        dfs2(v, child, u);
    }
}
  
static void addEdge(ArrayList> adj,
                    int u, int v)
{
    adj.get(u).add(v);
    adj.get(v).add(u);
}
  
// Function to print all the maximum heights
// from every node
static void printHeights(ArrayList> v,
                         int n)
{
      
    // Traversal to calculate in[] array
    dfs1(v, 1, 0);
  
    // Traversal to calculate out[] array
    dfs2(v, 1, 0);
  
    // Print all maximum heights
    for(int i = 1; i < n; i++)
        System.out.println(
            "The maximum height when node " + i +
            " is considered as root is " +
            Math.max(in[i], out[i]));
}
  
// Driver Code
public static void main(String[] args)
{
      
    // Creating a graph with 11 vertices
    int V = 12;
    ArrayList> adj = new ArrayList>(V + 1);
    for(int i = 0; i < V; i++)
        adj.add(new ArrayList());
  
    // Initialize the tree given in the diagram
    addEdge(adj, 1, 2);
    addEdge(adj, 1, 3);
    addEdge(adj, 1, 4);
    addEdge(adj, 2, 5);
    addEdge(adj, 2, 6);
    addEdge(adj, 3, 7);
    addEdge(adj, 7, 10);
    addEdge(adj, 7, 11);
    addEdge(adj, 4, 8);
    addEdge(adj, 4, 9);
  
    // Function to print the maximum height
    // from every node
    printHeights(adj, V);
}
}
  
// This code is contributed by decoding


Python3
# Python3 code to find the maximum path length
# considering any node as root
inn = [0] * 100
out = [0] * 100
  
# function to pre-calculate the array inn[]
# which stores the maximum height when travelled
# via branches
def dfs1(v, u, parent):
    global inn, out
      
    # initially every node has 0 height
    inn[u] = 0
  
    # traverse in the subtree of u
    for child in v[u]:
  
        # if child is same as parent
        if (child == parent):
            continue
  
        # dfs called
        dfs1(v, child, u)
  
        # recursively calculate the max height
        inn[u] = max(inn[u], 1 + inn[child])
  
# function to pre-calculate the array ouut[]
# which stores the maximum height when traveled
# via parent
def dfs2(v, u, parent):
    global inn, out
      
    # stores the longest and second
    # longest branches
    mx1, mx2 = -1, -1
  
    # traverse in the subtress of u
    for child in v[u]:
        if (child == parent):
            continue
  
        # compare and store the longest
        # and second longest
        if (inn[child] >= mx1):
            mx2 = mx1
            mx1 = inn[child]
  
        elif (inn[child] > mx2):
            mx2 = inn[child]
  
    # traverse in the subtree of u
    for child in v[u]:
        if (child == parent):
            continue
  
        longest = mx1
  
        # if longest branch has the node, then
        # consider the second longest branch
        if (mx1 == inn[child]):
            longest = mx2
  
        # recursively calculate out[i]
        out[child] = 1 + max(out[u], 1 + longest)
  
        # dfs function call
        dfs2(v, child, u)
  
# function to prall the maximum heights
# from every node
def printHeights(v, n):
    global inn, out
      
    # traversal to calculate inn[] array
    dfs1(v, 1, 0)
  
    # traversal to calculate out[] array
    dfs2(v, 1, 0)
  
    # prall maximum heights
    for i in range(1, n + 1):
        print("The maximum height when node", i, "is considered as root is", max(inn[i], out[i]))
  
# Driver Code
if __name__ == '__main__':
    n = 11
    v = [[] for i in range(n + 1)]
  
    # initialize the tree given in the diagram
    v[1].append(2)
    v[2].append(1)
    v[1].append(3)
    v[3].append(1)
    v[1].append(4)
    v[4].append(1)
    v[2].append(5)
    v[5].append(2)
    v[2].append(6)
    v[6].append(2)
    v[3].append(7)
    v[7].append(3)
    v[7].append(10)
    v[10].append(7)
    v[7].append(11)
    v[11].append(7)
    v[4].append(8)
    v[8].append(4)
    v[4].append(9)
    v[9].append(4)
  
    # function to prthe maximum height from every node
    printHeights(v, n)
  
# This code is contributed by mohit kumar 29.


输出 :
The maximum height when node 1 is considered as root is 3
The maximum height when node 2 is considered as root is 4
The maximum height when node 3 is considered as root is 3
The maximum height when node 4 is considered as root is 4
The maximum height when node 5 is considered as root is 5
The maximum height when node 6 is considered as root is 5
The maximum height when node 7 is considered as root is 4
The maximum height when node 8 is considered as root is 5
The maximum height when node 9 is considered as root is 5
The maximum height when node 10 is considered as root is 5
The maximum height when node 11 is considered as root is 5

时间复杂度: O(N)
辅助空间: O(N)