访问树的所有特殊节点所需的最短时间

给定一个由N个顶点组成的无向树，其中某些节点是特殊节点，任务是在最短的时间内从根节点访问所有特殊节点。从一个节点到另一节点的传播时间可以假定为单位时间。

A node is special if the path from the root to the node consists of distinct value nodes.

例子：

Input: N = 7, edges[] = {(0, 1), (0, 2), (1, 4), (1, 5), (2, 3), (2, 6)} 
isSpecial[] = {false, false, true, false, true, true, false} 
Output: 8 
Explanation: 

Input: N = 7, edges[] = {(0, 1), (0, 2), (1, 4), (1, 5), (2, 3), (2, 6)} 
isSpecial[] = {false, false, true, false, false, true, false} 
Output: 6 
Explanation: 

方法：想法是使用深度优先搜索遍历并遍历节点。如果任何节点都有一个作为特殊节点的子节点，则在该节点所需的步骤中添加两个。还要将该节点标记为特殊节点，以便在上移步骤时将其考虑在内。

下面是上述方法的实现：

C++

// C++ implementation to find
// the minimum time required to
// visit special nodes of a tree
 
#include 
using namespace std;
 
const int N = 100005;
 
// Time required to collect
vector ans(N, 0);
 
vector flag(N, 0);
 
// Minimum time required to reach
// all the special nodes of tree
void minimumTime(int u, int par,
                 vector& hasApple,
                 vector adj[])
{
 
    // Condition to check if
    // the vertex has apple
    if (hasApple[u] == true)
        flag[u] = 1;
 
    // Iterate all the
    // adjacent of vertex u.
    for (auto it : adj[u]) {
 
        // if adjacent vertex
        // is it's parent
        if (it != par) {
            minimumTime(it, u, hasApple, adj);
 
            // if any vertex of subtree
            // it contain apple
            if (flag[it] > 0)
                ans[u] += (ans[it] + 2);
 
            // flagbit for node u
            // would be on if any vertex
            // in it's subtree contain apple
            flag[u] |= flag[it];
        }
    }
}
 
// Driver Code
int main()
{
    // Number of the vertex.
    int n = 7;
 
    vector hasApple{ false, false,
                           true, false,
                           true, true,
                           false };
 
    // Store all the edges,
    // any edge represented
    // by pair of vertex
    vector > edges;
 
    // Added all the
    // edge in edges vector.
    edges.push_back(make_pair(0, 1));
    edges.push_back(make_pair(0, 2));
    edges.push_back(make_pair(1, 4));
    edges.push_back(make_pair(1, 5));
    edges.push_back(make_pair(2, 3));
    edges.push_back(make_pair(2, 6));
 
    // Adjacent list
    vector adj[n];
 
    for (int i = 0; i < edges.size(); i++) {
        int source_node = edges[i].first;
 
        int destination_node
            = edges[i].second;
 
        adj[source_node]
            .push_back(destination_node);
 
        adj[destination_node]
            .push_back(source_node);
    }
 
    // Function Call
    minimumTime(0, -1, hasApple, adj);
 
    cout << ans[0];
    return 0;
}

Java

// Java implementation to find
// the minimum time required to
// visit special nodes of a tree
import java.util.*;
 
@SuppressWarnings("unchecked")
class GFG{
 
static class pair
{
    int first, second;
     
    pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}
 
static final int N = 100005;
  
// Time required to collect
static ArrayList ans;
static ArrayList flag;
  
// Minimum time required to reach
// all the special nodes of tree
static void minimumTime(int u, int par,
                        ArrayList hasApple,
                        ArrayList adj[])
{
     
    // Condition to check if
    // the vertex has apple
    if ((boolean)hasApple.get(u) == true)
        flag.set(u, 1);
  
    // Iterate all the
    // adjacent of vertex u.
    for(int it : (ArrayList)adj[u])
    {
         
        // If adjacent vertex
        // is it's parent
        if (it != par)
        {
            minimumTime(it, u, hasApple, adj);
  
            // If any vertex of subtree
            // it contain apple
            if ((int)flag.get(it) > 0)
                ans.set(u, (int)ans.get(u) +
                           (int)ans.get(it) + 2 );
  
            // flagbit for node u
            // would be on if any vertex
            // in it's subtree contain apple
            flag.set(u, (int)flag.get(u) |
                        (int)flag.get(it));
        }
    }
}
  
// Driver Code
public static void main(String []args)
{
     
    // Number of the vertex.
    int n = 7;
 
    ans = new ArrayList();
    flag = new ArrayList();
     
    for(int i = 0; i < N; i++)
    {
        ans.add(0);
        flag.add(0);
    }
     
    ArrayList hasApple = new ArrayList();
    hasApple.add(false);
    hasApple.add(false);
    hasApple.add(true);
    hasApple.add(false);
    hasApple.add(true);
    hasApple.add(true);
    hasApple.add(false);
  
    // Store all the edges,
    // any edge represented
    // by pair of vertex
    ArrayList edges = new ArrayList();
  
    // Added all the edge in
    // edges vector.
    edges.add(new pair(0, 1));
    edges.add(new pair(0, 2));
    edges.add(new pair(1, 4));
    edges.add(new pair(1, 5));
    edges.add(new pair(2, 3));
    edges.add(new pair(2, 6));
  
    // Adjacent list
    ArrayList []adj = new ArrayList[n];
 
    for(int i = 0; i < n; i++)
    {
        adj[i] = new ArrayList();
    }
  
    for(int i = 0; i < edges.size(); i++)
    {
        int source_node = ((pair)edges.get(i)).first;
        int destination_node = ((pair)edges.get(i)).second;
  
        adj[source_node].add(destination_node);
        adj[destination_node].add(source_node);
    }
  
    // Function Call
    minimumTime(0, -1, hasApple, adj);
     
    System.out.print(ans.get(0));
}
}
 
// This code is contributed by pratham76

Python3

# Python3 implementation to find
# the minimum time required to
# visit special nodes of a tree
N = 100005
  
# Time required to collect
ans = [0 for i in range(N)]
flag = [0 for i in range(N)]
  
# Minimum time required to reach
# all the special nodes of tree
def minimumTime(u, par, hasApple, adj):
  
    # Condition to check if
    # the vertex has apple
    if (hasApple[u] == True):
        flag[u] = 1
  
    # Iterate all the
    # adjacent of vertex u.
    for it in adj[u]:
  
        # if adjacent vertex
        # is it's parent
        if (it != par):
            minimumTime(it, u, hasApple, adj)
  
            # if any vertex of subtree
            # it contain apple
            if (flag[it] > 0):
                ans[u] += (ans[it] + 2)
  
            # flagbit for node u
            # would be on if any vertex
            # in it's subtree contain apple
            flag[u] |= flag[it]
  
# Driver Code
if __name__=='__main__':
 
    # Number of the vertex.
    n = 7
  
    hasApple = [ False, False, True,
                 False, True, True, False ]
  
    # Store all the edges,
    # any edge represented
    # by pair of vertex
    edges = []
  
    # Added all the
    # edge in edges vector.
    edges.append([0, 1])
    edges.append([0, 2])
    edges.append([1, 4])
    edges.append([1, 5])
    edges.append([2, 3])
    edges.append([2, 6])
  
    # Adjacent list
    adj = [[] for i in range(n)]
     
    for i in range(len(edges)):
        source_node = edges[i][0]
         
        destination_node = edges[i][1]
  
        adj[source_node].append(destination_node)
        adj[destination_node].append(source_node)
     
    # Function Call
    minimumTime(0, -1, hasApple, adj);
     
    print(ans[0])
     
# This code is contributed by rutvik_56

输出：

8