给定类型为{X，Y}的2D数组edge [] [] ，它表示树中的节点X和Y之间有一条边，而数组color []表示第i个节点的颜色值，任务是找到树的根节点，以使根节点在同一路径上的所有子节点具有相同的颜色值。如果存在多个解决方案，则打印其中任何一种。否则，打印-1 。
例子：
Input:
Output: 2
Explanation:
All the child nodes on the path from the root node(= 2) to the leaf node(= 1) have the same value of the color(= 1).
All the child nodes on the path from the root node(= 2) to the leaf node(= 4) have the same value of the color(= 1).
Therefore, the required output is 2.
Input:
Output: 2
Explanation:
All the child nodes on the path from the root node(=2) to the leaf node(=9) have the same value of the color(= 4).
All the child nodes on the path from the root node(=2) to the leaf node(=1) have the same value of the color(= 1).
All the child nodes on the path from the root node(=2) to the leaf node(=5) have the same value of the color(= 2).
All the child nodes on the path from the root node(=2) to the leaf node(=6) have the same value of the color(= 3).
方法：想法是遍历树的所有可能的节点。对于第i个节点，请检查其是否满足根节点的条件或不使用DFS。如果发现为真，则打印该节点。否则，打印-1 。请按照以下步骤解决问题：
- 初始化一个变量，例如root ，以存储满足条件的树的根节点。
- 遍历树的所有可能节点。将树的每个第i个节点视为根节点，并检查从根节点到叶节点的路径上的所有子节点是否具有相同的颜色或不使用DFS。如果发现为真，则打印该节点。
- 否则，打印-1 。
下面是上述方法的实现：
C++
// C++ program to implement
// the above approach
#include
using namespace std;
// Function to perform dfs on the tree
bool dfs(int node, int c, vector adj[],
int color[], int visited[])
{
// Mark visited node as true
visited[node] = true;
// If color does not match with
// previous node on the same path
if (color[node] != c) {
return false;
}
// Check if current subtree
// has all same colored nodes
int f = 1;
// Traverse all unvisited neighbors
// node of the tree
for (int j = 0; j < adj[node].size(); j++) {
// Stores neighbors node
// of the tree
int neighbor = adj[node][j];
// If current node is not
// already visited
if (!visited[neighbor]) {
if (dfs(neighbor, c, adj,
color, visited)
== false) {
// Update f
f = 0;
break;
}
}
}
return f;
}
// Function to find the root node of
// the tree such that all child nodes
// on the same path have the same color
void findNode(int edges[][2],
int color[], int n)
{
// Store the adjacency list
vector adj[n + 1];
// Traverse all edges and form
// the adjacency list
for (int i = 0; i < n - 1; i++) {
int a = edges[i][0];
int b = edges[i][1];
adj[a].push_back(b);
adj[b].push_back(a);
}
// Store the root node such that all
// child nodes on the same path have
// the same color
int ans = -1;
// Iterate over all possible
// nodes of the tree
for (int i = 1; i <= n; i++) {
// Check if node i satisfies
// the condition of root node
int f = 1;
// Check if a node has been
// visited or not
int visited[n + 1] = { false };
// Mark visited[i] as true
visited[i] = true;
// Traverse all the neighbors
// of node i
for (int j = 0; j < adj[i].size(); j++) {
// Stores the current neighbor
int neighbor = adj[i][j];
// Perform DFS for current neighbor
if (dfs(neighbor, color[neighbor],
adj, color, visited)
== false) {
// Update f
f = 0;
break;
}
}
if (f == 1) {
ans = i;
break;
}
}
// Print the answer
cout << ans;
}
// Driver Code
int main()
{
int n = 9;
int color[n + 1] = { -1, 1, 1, 2, 2,
2, 3, 3, 4, 4 };
int edges[][2] = { { 1, 2 }, { 2, 3 },
{ 3, 4 }, { 4, 5 },
{ 2, 7 }, { 7, 6 },
{ 2, 8 }, { 8, 9 } };
findNode(edges, color, n);
return 0;
} Java
// Java program to implement
// the above approach
import java.util.*;
class GFG
{
// Function to perform dfs on the tree
static boolean dfs(int node, int c, Vector adj[],
int color[], boolean visited[])
{
// Mark visited node as true
visited[node] = true;
// If color does not match with
// previous node on the same path
if (color[node] != c)
{
return false;
}
// Check if current subtree
// has all same colored nodes
boolean f = true;
// Traverse all unvisited neighbors
// node of the tree
for (int j = 0; j < adj[node].size(); j++)
{
// Stores neighbors node
// of the tree
int neighbor = adj[node].get(j);
// If current node is not
// already visited
if (!visited[neighbor])
{
if (dfs(neighbor, c, adj,
color, visited) == false)
{
// Update f
f = false;
break;
}
}
}
return f;
}
// Function to find the root node of
// the tree such that all child nodes
// on the same path have the same color
static void findNode(int edges[][],
int color[], int n)
{
// Store the adjacency list
Vector []adj = new Vector[n + 1];
for(int i = 0; i < n + 1; i++)
adj[i] = new Vector();
// Traverse all edges and form
// the adjacency list
for (int i = 0; i < n - 1; i++)
{
int a = edges[i][0];
int b = edges[i][1];
adj[a].add(b);
adj[b].add(a);
}
// Store the root node such that all
// child nodes on the same path have
// the same color
int ans = -1;
// Iterate over all possible
// nodes of the tree
for (int i = 1; i <= n; i++)
{
// Check if node i satisfies
// the condition of root node
int f = 1;
// Check if a node has been
// visited or not
boolean []visited = new boolean[n + 1];
// Mark visited[i] as true
visited[i] = true;
// Traverse all the neighbors
// of node i
for (int j = 0; j < adj[i].size(); j++)
{
// Stores the current neighbor
int neighbor = adj[i].get(j);
// Perform DFS for current neighbor
if (dfs(neighbor, color[neighbor],
adj, color, visited) == false)
{
// Update f
f = 0;
break;
}
}
if (f == 1)
{
ans = i;
break;
}
}
// Print the answer
System.out.print(ans);
}
// Driver Code
public static void main(String[] args)
{
int n = 9;
int color[] = { -1, 1, 1, 2, 2,
2, 3, 3, 4, 4 };
int edges[][] = { { 1, 2 }, { 2, 3 },
{ 3, 4 }, { 4, 5 },
{ 2, 7 }, { 7, 6 },
{ 2, 8 }, { 8, 9 } };
findNode(edges, color, n);
}
}
// This code is contributed by 29AjayKumar Python3
# Python program to implement
# the above approach
from typing import List
# Function to perform dfs on the tree
def dfs(node: int, c: int, adj: List[List[int]],
color: List[int],
visited: List[int]) -> bool:
# Mark visited node as true
visited[node] = True
# If color does not match with
# previous node on the same path
if (color[node] != c):
return False
# Check if current subtree
# has all same colored nodes
f = 1
# Traverse all unvisited neighbors
# node of the tree
for j in range(len(adj[node])):
# Stores neighbors node
# of the tree
neighbor = adj[node][j]
# If current node is not
# already visited
if (not visited[neighbor]):
if not dfs(neighbor, c, adj, color, visited):
# Update f
f = 0
break
return f
# Function to find the root node of
# the tree such that all child nodes
# on the same path have the same color
def findNode(edges: List[List[int]], color: List[int], n: int) -> None:
# Store the adjacency list
adj = [[] for _ in range(n + 1)]
# Traverse all edges and form
# the adjacency list
for i in range(n - 1):
a = edges[i][0]
b = edges[i][1]
adj[a].append(b)
adj[b].append(a)
# Store the root node such that all
# child nodes on the same path have
# the same color
ans = -1
# Iterate over all possible
# nodes of the tree
for i in range(1, n + 1):
# Check if node i satisfies
# the condition of root node
f = 1
# Check if a node has been
# visited or not
visited = [False for _ in range(n + 1)]
# Mark visited[i] as true
visited[i] = True
# Traverse all the neighbors
# of node i
for j in range(len(adj[i])):
# Stores the current neighbor
neighbor = adj[i][j]
# Perform DFS for current neighbor
if not dfs(neighbor, color[neighbor],
adj, color, visited):
# Update f
f = 0
break
if (f == 1):
ans = i
break
# Print the answer
print(ans)
# Driver Code
if __name__ == "__main__":
n = 9
color = [-1, 1, 1, 2, 2, 2, 3, 3, 4, 4]
edges = [[1, 2], [2, 3], [3, 4], [4, 5], [2, 7], [7, 6], [2, 8], [8, 9]]
findNode(edges, color, n)
# This code is contributed by sanjeev2552C#
// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG
{
// Function to perform dfs on the tree
static bool dfs(int node, int c, List []adj,
int []color, bool []visited)
{
// Mark visited node as true
visited[node] = true;
// If color does not match with
// previous node on the same path
if (color[node] != c)
{
return false;
}
// Check if current subtree
// has all same colored nodes
bool f = true;
// Traverse all unvisited neighbors
// node of the tree
for (int j = 0; j < adj[node].Count; j++)
{
// Stores neighbors node
// of the tree
int neighbor = adj[node][j];
// If current node is not
// already visited
if (!visited[neighbor])
{
if (dfs(neighbor, c, adj,
color, visited) == false)
{
// Update f
f = false;
break;
}
}
}
return f;
}
// Function to find the root node of
// the tree such that all child nodes
// on the same path have the same color
static void findNode(int [,]edges,
int []color, int n)
{
// Store the adjacency list
List []adj = new List[n + 1];
for(int i = 0; i < n + 1; i++)
adj[i] = new List();
// Traverse all edges and form
// the adjacency list
for (int i = 0; i < n - 1; i++)
{
int a = edges[i, 0];
int b = edges[i, 1];
adj[a].Add(b);
adj[b].Add(a);
}
// Store the root node such that all
// child nodes on the same path have
// the same color
int ans = -1;
// Iterate over all possible
// nodes of the tree
for (int i = 1; i <= n; i++)
{
// Check if node i satisfies
// the condition of root node
int f = 1;
// Check if a node has been
// visited or not
bool []visited = new bool[n + 1];
// Mark visited[i] as true
visited[i] = true;
// Traverse all the neighbors
// of node i
for (int j = 0; j < adj[i].Count; j++)
{
// Stores the current neighbor
int neighbor = adj[i][j];
// Perform DFS for current neighbor
if (dfs(neighbor, color[neighbor],
adj, color, visited) == false)
{
// Update f
f = 0;
break;
}
}
if (f == 1)
{
ans = i;
break;
}
}
// Print the answer
Console.Write(ans);
}
// Driver Code
public static void Main(String[] args)
{
int n = 9;
int []color = { -1, 1, 1, 2, 2,
2, 3, 3, 4, 4 };
int [,]edges = { { 1, 2 }, { 2, 3 },
{ 3, 4 }, { 4, 5 },
{ 2, 7 }, { 7, 6 },
{ 2, 8 }, { 8, 9 } };
findNode(edges, color, n);
}
}
// This code is contributed by 29AjayKumar 输出：
2时间复杂度： O(N 2 )
辅助空间： O(N)