检查是否最多可以通过N / 2个给定操作从树的节点访问每个节点

给定一个由N个节点组成的有向树，任务是检查给定树中是否存在一个节点，以便通过从树中删除任何有向边并在树中的任何一对节点之间添加另一个有向边来使所有其他节点均可达。树至多地板(N / 2)次。如果存在任何这样的节点，则打印“是” 。否则，打印“否” 。

例子：

Input: N = 3

Output: Yes
Explanation: 
Remove the edge 2 -> 3 and insert an edge 1 -> 3. 

Therefore, both the remaining nodes (2, 3) are now accessible from the node 1.
Count of operations required is 1, which is <= floor(3/2) (= 1).
Input: N = 5

Output: No

方法：解决此问题的想法是基于以下观察结果：

• 每个节点至少应该有一个父节点，即每个节点至少应该有1个入度，使树从所需要的节点访问。
• 可以得出结论，如果每个节点的度数至少为1 ，则可以访问所有其他节点。
• 因此，该任务简化为找到度数为0的节点数，并检查其是否最大为N / 2 。

请按照以下步骤解决问题：

• 将树中每个节点的入度存储在大小为(N + 1)的辅助数组A []中。
• 将此映射初始化为Map中所有(键-值)对的A [key] =对。
• 初始化一个变量，例如count为0，以存储度数等于0的节点数。
• 遍历数组A []并计算值为0的数组元素的数量，并将其存储在变量count中。
• 完成上述步骤后，如果count的值最大为floor(N / 2) ，则打印“ Yes” 。否则，打印“否” 。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include
using namespace std;
 
void findNode(map mp, int n)
{
     
    // Store the indegree
    // of every node
    int a[n];
 
    for(int i = 0; i < n; i++)
    {
        a[i] = mp[i + 1];
    }
 
    // Store the nodes having
    // indegree equal to 0
    int count0 = 0;
 
    // Traverse the array
    for(int i = 0; i < n; i++)
    {
         
        // If the indegree
        // of i-th node is 0
        if (a[i] == 0)
        {
             
            // Increment count0 by 1
            count0++;
        }
    }
 
    count0 -= 1;
 
    // If the number of operations
    // needed is at most floor(n/2)
    if (count0 <= floor(((double)n) /
                        ((double)2)))
    {
        cout << "Yes";
    }
 
    // Otherwise
    else
        cout << "No";
}
 
// Driver Code
int main()
{
     
    // Given number of nodes
    int N = 3;
 
    // Given Directed Tree
    map mp;
    mp[1] = 0;
    mp[2] = 2;
    mp[3] = 0;
 
    findNode(mp, N);
}
 
// This code is contributed by SURENDRA_GANGWAR

Java

// Java program for the above approach
import java.io.*;
import java.util.HashMap;
 
class GFG {
 
    // Function to check if there is a
    // node in tree from where all other
    // nodes are accessible or not
    public static void
    findNode(HashMap map,
             int n)
    {
 
        // Store the indegree
        // of every node
        int[] a = new int[n];
 
        for (int i = 0; i < n; i++) {
            a[i] = map.getOrDefault(i + 1, 0);
        }
 
        // Store the nodes having
        // indegree equal to 0
        int count0 = 0;
 
        // Traverse the array
        for (int i = 0; i < n; i++) {
 
            // If the indegree
            // of i-th node is 0
            if (a[i] == 0) {
 
                // Increment count0 by 1
                count0++;
            }
        }
 
        count0 -= 1;
 
        // If the number of operations
        // needed is at most floor(n/2)
        if (count0
            <= Math.floor(((double)n)
                          / ((double)2))) {
            System.out.println("Yes");
        }
 
        // Otherwise
        else
            System.out.println("No ");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        // Given number of nodes
        int N = 3;
 
        // Given Directed Tree
        HashMap map
            = new HashMap<>();
 
        map.put(1, 0);
        map.put(2, 2);
        map.put(3, 0);
 
        findNode(map, N);
    }
}

输出：

Yes

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