CareerCup

public class Node<T> where T : IComparable
    {
        public T Data { get; set; }

        public List<Node<T>> Childern { get; set; }

        public Node(T data)
        {
            this.Data = data;
            this.Childern = new List<Node<T>>();
        }
        
        public void AddNode(Node<T> n)
        {
            this.Childern.Add(n);
        }

        public int FindMaxDepth()
        {
            return FindMaxDeptOnNode(this);
        }

        private int FindMaxDeptOnNode(Node<T> n)
        {
            if (n == null)
            {
                return 0;
            }

            int kidDepth = 0;
            int maxDepth = 0;

            for (int i = 0; i < n.Childern.Count; i++)
            {
                kidDepth = FindMaxDeptOnNode(n.Childern[i]) + 1;
                if (kidDepth > maxDepth)
                {
                    maxDepth = kidDepth;
                }
            }

            return maxDepth;
        }
    }

Both BFS and DFS should work, though I will prefer BFS.

import java.util.ArrayList;
import java.util.List;


public class Node {
List<Node> nodelist = new ArrayList<Node>();
public void addNode(Node node){
nodelist.add(node);
}
static int count;
static int max;
//Assuming if a node has a child, path length between them is 1
public static int maxPathLength(Node node){
searchNode(node);
return max;
}
public static void searchNode(Node node){
if(count>max)
max = count;
count++;
for(Node cNode : node.nodelist){
searchNode(cNode);
}
count--;
}
}