Minimum distance between two given nodes in an N-ary tree

// Java program for the above approach
import java.util.*;
public class Main
{
    // Structure of Node
    static class Node {
        
        public int val;
        public Node left, right;
        public Vector<Node> child;
        
        public Node(int key)
        {
            val = key;
            left = right = null;
            child = new Vector<Node>();
        }
    }
    
    // Utility function to create a
    // new tree node
    static Node newNode(int key)
    {
        Node temp = new Node(key);
        return temp;
    }
     
    static int flag;
     
    // Function to get the path
    // from root to a node
    static void findPath(Node root, int key,
                  Vector<Integer> arr)
    {
        if (root==null)
            return;
        arr.add(root.val);
        // if key is found set flag and return
        if (root.val == key) {
            flag = 1;
            return;
        }
        // recur for all children
        for (int i = 0; i < root.child.size(); i++) {
     
            findPath(root.child.get(i), key, arr);
     
            // if key is found dont need to pop values
            if (flag == 1)
                return;
        }
     
        arr.remove(arr.size()-1);
        return;
    }
     
    static void findMinDist(Node root, int A, int B)
    {
        if (root == null)
            return;
        int val = root.val;
     
        // vector to store both paths
        Vector<Integer> arr1 = new Vector<Integer>();
        Vector<Integer> arr2 = new Vector<Integer>();
     
        // set flag as false;
        flag = 0;
     
        // find path from root to node a
        findPath(root, A, arr1);
     
        // set flag again as false;
        flag = 0;
     
        // find path from root to node b
        findPath(root, B, arr2);
     
        // to store index of LCA node
        int j=0;
     
        // if unequal values are found
        // return previous value
        for (int i = 1; i < Math.min(arr1.size(), arr2.size()); i++) {
            if (arr1.get(i) != arr2.get(i)) {
                val = arr1.get(i - 1);
                j = i - 1;
                break;
            }
        }
        int d1 = 0, d2 = 0;
     
        // iterate for finding distance
        // between LCA(a, b) and a
        for (int i = j; i < arr1.size(); i++)
            if (arr1.get(i) == A)
                break;
            else
                d1 += 1;
     
        // iterate for finding distance
        // between LCA(a, b) and b
        for (int i = j; i < arr2.size(); i++)
            if (arr2.get(i) == B)
                break;
            else
                d2 += 1;
        // get distance
        val = d1 + d2;
        System.out.println(val);
    }
    
    public static void main(String[] args) {
        Node root = newNode(1);
        (root.child).add(newNode(2));
        (root.child).add(newNode(3));
        (root.child.get(0).child).add(newNode(4));
        (root.child.get(0).child).add(newNode(5));
        (root.child.get(1).child).add(newNode(6));
        (root.child.get(1)).child.add(newNode(7));
        (root.child.get(1).child).add(newNode(8));
        int A = 4, B = 3;
     
        // get min distance
        findMinDist(root, A, B);
    }
}

// This code is contributed by mukesh07.