如果保持节点之间的关系，则两个 K-Way 树是等价的

Question

Two k-way trees are given, T1 and T2. If any two nodes (A, B) from T1 has the property that node B is the descendant of A and that relationship is maintained in the second tree T2 then T1 is equivalent to T2. A k-way tree is defined to be one where a node can have up to up to k branches at a node. Determine if two k-way trees are equivalent.

Any ideas on a very efficient algorithm in terms of both time and space and beat this one would be appreciated.

For example, T1 and T2 are equivalent.

T1:

        n1
      / |  \
     n2 n3  n4
    / \
   n5  n6
      / | \
     n7 n8 n9
             \
             n12

T2:

        n10
      / |  \
     n3 n6  n2
    /   |    | \
   n15  n9   n0 n7

My attempt:

Make an adjacency list of T1:n1: {n2, n3, n4}, n2: {n5, n6}, n3: {}, n4: {}, n5: {}, n6: {n7, n8, n9}, n9: {n12}, n12: {}

Make and adjacency list of T2: n10: {n3, n6, n2}, n6: {n9}, n2: {n0, n7}, ...

1. Go over each node in T2 and check if they are in T1. Store these nodes.
2. Create all the possible pairs from these nodes.
3. Go over each pair, start from one node in T1 and do dfs to see if it reaches the second node.

For example ,

Pick (n9, n6). Use the T1 adjacency list to see if n6 is reachable from n9. It is not possible. At some point we will get to pair (n6, n9) and will start from n6. Is n9 reachable from n6? Yes.

Worst Space :

• Assume num_nodes in T1 = num_x
• Assume num_nodes in T2 = num_y
• Worst case space: O(num_x + num_y + (num_y*(num_y-1) ) // last term is for the pairs

Worst time :

• Time to create all the pairs: O(num_y * (num_y-1))
• Time to determine if two nodes are reachable in T1 linked in T1: O(height of T1) = O(h)
• Total time = O(h * num_y * (num_y-1))

Maybe to determine if two nodes are reachable in T1 an euler tour and rmq could achieve it in O(1)

Answer 1

Can be solved efficiently using Euler's tour of given trees.

First observe that you only need to consider the nodes set S = intersection of T1 and T2 . Create euler's tour of the T1 and ignore any node which is not is S (but don't avoid doing DFS for subtree of S ).

Put the nodes as they appear in the euler's tour and for each node stores two integers - the starting index in the euler tour array and ending index in the array. Ending index is the index where you leave the DFS of that node at return to it's parent. Let's denote these indexes array by st[] and en[] . Also store it's own index so that we can query later at what index is the node itself. Let's call this array as idx[]

Now, performing a DFS in T2 and avoiding any nodes which appear in S we can form pairs for the relation of ancestor and descendant. There could be total O(m. m) such pairs in worst case for m = number of total nodes in T2

For any pair A, D to check whether A is ancestor of D in T1 as well use the indexes we created earlier for each node of T1 in its Euler tour.

st[A] < idx[D] < en[A] then we have that relationship, otherwise not.

Total time complexity is O(m. m)