# GCD from root to leaf path in an N-ary tree

Given an **N-ary tree** and an array **val[]** which stores the values associated with all the nodes. Also given are a leaf node **X** and **N** integers which denotes the value of the node. The task is to find the **gcd** of all the numbers in the node in the path between leaf to the root.

**Examples:**

Input:1 / \ 2 3 / / \ 4 5 6 / \ 7 8 val[] = { -1, 6, 2, 6, 3, 4, 12, 10, 18 } leaf = 8Output:6 GCD(val[1], val[3], val[6], val[8]) = GCD(6, 6, 12, 18) = 6Input:1 / \ 2 3 / / \ 4 5 6 / \ 7 8 val[] = { 6, 2, 6, 3, 4, 12, 10, 18 } leaf = 5Output:2

**Approach:** The problem can be solved using DFS in a tree. In the DFS function, we include an extra parameter G with the initial value as the root. Every time we visit a new node by calling DFS function recursively, we update the value of **G** to **gcd(G, val[node]) **. Once we reach the given leaf node, we print the value of gcd(G, val[leaf-node]) and break out of DFS function.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` `#define N 9 ` ` ` `// Function to add edges in the tree ` `void` `addEgde(list<` `int` `>* 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<` `int` `>* 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<` `int` `>* adj = ` `new` `list<` `int` `>[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; ` `} ` |

*chevron_right*

*filter_none*

## 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

**Output:**

2

## Recommended Posts:

- Print the first shortest root to leaf path in a Binary Tree
- Find the maximum sum leaf to root path in a Binary Tree
- Find if there is a pair in root to a leaf path with sum equals to root's data
- Check if there is a root to leaf path with given sequence
- Root to leaf path sum equal to a given number
- Print the longest leaf to leaf path in a Binary tree
- Root to leaf path with maximum distinct nodes
- Shortest root to leaf path sum equal to a given number
- Sum of nodes on the longest path from root to leaf node
- Root to leaf path product equal to a given number
- Given a binary tree, print all root-to-leaf paths
- Given a binary tree, print out all of its root-to-leaf paths one per line.
- Root to leaf paths having equal lengths in a Binary Tree
- Sort the path from root to a given node in a Binary Tree
- Print path from root to a given node in a binary tree

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.