N元树中从根到叶路径的GCD

给定一个N元树和一个数组val [] ，该数组存储与所有节点关联的值。还给出了叶节点X和N的整数，它们表示该节点的值。任务是在叶到根之间的路径中找到节点中所有数字的gcd 。

例子：

Input: 
            1
          /   \ 
        2      3
      /      /   \ 
     4      5     6 
                /   \
              7      8 

val[] = { -1, 6, 2, 6, 3, 4, 12, 10, 18 } 
leaf = 8 
Output: 6 

GCD(val[1], val[3], val[6], val[8]) = GCD(6, 6, 12, 18) = 6 

Input:
            1
          /   \ 
        2      3
      /      /   \ 
     4      5     6 
                /   \
              7      8 

val[] = { 6, 2, 6, 3, 4, 12, 10, 18 }
leaf = 5  
Output: 2

方法：可以在树中使用DFS解决该问题。在DFS函数，我们包括一个附加参数G，其初始值作为根。每次我们通过递归调用DFS函数访问新节点时，都会将G的值更新为gcd(G，val [node]) 。到达给定的叶节点后，我们将打印gcd(G，val [leaf-node])的值，然后脱离DFS函数。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
#define N 9
  
// Function to add edges in the tree
void addEgde(list* adj, int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
  
// Function to find the GCD from root to leaf path
void DFS(int node, int parent, int G, int leaf,
         int val[], list* adj)
{
    // If we reach the desired leaf
    if (node == leaf) {
        G = __gcd(G, val[node]);
        cout << G;
        return;
    }
  
    // Call DFS for children
    for (auto it : adj[node]) {
  
        if (it != parent)
            DFS(it, node, __gcd(G, val[it]), leaf, val, adj);
    }
}
  
// Driver code
int main()
{
  
    int n = 8;
    list* adj = new list[n + 1];
  
    addEgde(adj, 1, 2);
    addEgde(adj, 2, 4);
    addEgde(adj, 1, 3);
    addEgde(adj, 3, 5);
    addEgde(adj, 3, 6);
    addEgde(adj, 6, 7);
    addEgde(adj, 6, 8);
  
    int leaf = 5;
  
    // -1 to indicate no value in node 0
    int val[] = { -1, 6, 2, 6, 3, 4, 12, 10, 18 };
  
    // Initially GCD is the value of the root
    int G = val[1];
  
    DFS(1, -1, G, leaf, val, adj);
  
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
  
class GFG
{
static final int N = 9;
  
// Function to add edges in the tree
static void addEgde(List []adj, int u, int v)
{
    adj[u].add(v);
    adj[v].add(u);
}
  
// Function to find the GCD from root to leaf path
static void DFS(int node, int parent, int G, int leaf,
        int val[], List []adj)
{
    // If we reach the desired leaf
    if (node == leaf)
    {
        G = __gcd(G, val[node]);
        System.out.print(G);
        return;
    }
  
    // Call DFS for children
    for (int it : adj[node]) 
    {
  
        if (it != parent)
            DFS(it, node, __gcd(G, val[it]), leaf, val, adj);
    }
}
static int __gcd(int a, int b) 
{ 
    return b == 0? a:__gcd(b, a % b);     
}
  
// Driver code
public static void main(String[] args)
{
  
    int n = 8;
    List []adj = new LinkedList[n + 1];
        for (int i = 0; i < n + 1; i++)
            adj[i] = new LinkedList();
    addEgde(adj, 1, 2);
    addEgde(adj, 2, 4);
    addEgde(adj, 1, 3);
    addEgde(adj, 3, 5);
    addEgde(adj, 3, 6);
    addEgde(adj, 6, 7);
    addEgde(adj, 6, 8);
  
    int leaf = 5;
  
    // -1 to indicate no value in node 0
    int val[] = { -1, 6, 2, 6, 3, 4, 12, 10, 18 };
  
    // Initially GCD is the value of the root
    int G = val[1];
  
    DFS(1, -1, G, leaf, val, adj);
}
}
  
// This code is contributed by 29AjayKumar

Python3

# Python 3 implementation of the approach
from math import gcd
N = 9
  
# Function to add edges in the tree
def addEgde(adj, u, v):
    adj[u].append(v)
    adj[v].append(u)
  
# Function to find the GCD 
# from root to leaf path
def DFS(node, parent, G, leaf, val, adj):
      
    # If we reach the desired leaf
    if (node == leaf):
        G = gcd(G, val[node])
        print(G, end = "")
        return
  
    # Call DFS for children
    for it in adj[node]:
        if (it != parent):
            DFS(it, node, gcd(G, val[it]),
                          leaf, val, adj)
  
# Driver code
if __name__ == '__main__':
    n = 8
    adj = [[0 for i in range(n + 1)] 
              for j in range(n + 1)]
   
    addEgde(adj, 1, 2)
    addEgde(adj, 2, 4)
    addEgde(adj, 1, 3)
    addEgde(adj, 3, 5)
    addEgde(adj, 3, 6)
    addEgde(adj, 6, 7)
    addEgde(adj, 6, 8)
  
    leaf = 5
  
    # -1 to indicate no value in node 0
    val = [-1, 6, 2, 6, 3, 4, 12, 10, 18]
  
    # Initially GCD is the value of the root
    G = val[1]
  
    DFS(1, -1, G, leaf, val, adj)
  
# This code is contributed by
# Surendra_Gangwar

C#

// C# implementation of the approach
using System;
using System.Collections.Generic;
  
class GFG
{
static readonly int N = 9;
   
// Function to add edges in the tree
static void addEgde(List []adj, int u, int v)
{
    adj[u].Add(v);
    adj[v].Add(u);
}
   
// Function to find the GCD from root to leaf path
static void DFS(int node, int parent, int G, int leaf,
        int []val, List []adj)
{
    // If we reach the desired leaf
    if (node == leaf)
    {
        G = __gcd(G, val[node]);
        Console.Write(G);
        return;
    }
   
    // Call DFS for children
    foreach (int it in adj[node]) 
    {
   
        if (it != parent)
            DFS(it, node, __gcd(G, val[it]), leaf, val, adj);
    }
}
static int __gcd(int a, int b) 
{ 
    return b == 0? a:__gcd(b, a % b);     
}
   
// Driver code
public static void Main(String[] args)
{
   
    int n = 8;
    List []adj = new List[n + 1];
        for (int i = 0; i < n + 1; i++)
            adj[i] = new List();
    addEgde(adj, 1, 2);
    addEgde(adj, 2, 4);
    addEgde(adj, 1, 3);
    addEgde(adj, 3, 5);
    addEgde(adj, 3, 6);
    addEgde(adj, 6, 7);
    addEgde(adj, 6, 8);
   
    int leaf = 5;
   
    // -1 to indicate no value in node 0
    int []val = { -1, 6, 2, 6, 3, 4, 12, 10, 18 };
   
    // Initially GCD is the value of the root
    int G = val[1];
   
    DFS(1, -1, G, leaf, val, adj);
}
}
  
// This code is contributed by PrinciRaj1992

输出：

2