using System;

using System.Collections.Generic;

​

public class CustomNode

{

    public string Title;

    public CustomNode Parent;

    public List<CustomNode> Children;

​

    public CustomNode(string title, CustomNode parent)

    {

        Title = title;

        Parent = parent;

        Children = new List<CustomNode>();

​

        if (Parent != null)

            Parent.Children.Add(this);

    }

​

    public CustomNode Find(string path)

    {

        if (path == Title)

            return this;

​

        string[] pieces = path.Split(new char[] { '/' });

​

        foreach (var child in Children)

        {

            if (child.Title == pieces[1])

                return child.Find(path.Remove(0, Title.Length + 1));

        }

​

        return null;

    }

}

​

public class Test

{

    public static void Main()

    {

        //Build a test tree (matches the example)

        CustomNode root = new CustomNode("Root", null);

        CustomNode userData = new CustomNode("UserData", root);

        CustomNode ud_browser = new CustomNode("Browser", userData);

        CustomNode ud_word = new CustomNode("Word", userData);

        CustomNode priv = new CustomNode("Private", userData);

        CustomNode priv_word = new CustomNode("Word", priv);

​

        CustomNode windows = new CustomNode("Windows", root);

        CustomNode programs = new CustomNode("Programs", root);

        CustomNode notepad = new CustomNode("Notepad", programs);

        CustomNode prog_word = new CustomNode("Word", programs);

        CustomNode prog_browser = new CustomNode("Browser", programs);

​

        //CustomNode custom1 = new CustomNode(Console.ReadLine(), root);

        //CustomNode custom2 = new CustomNode(Console.ReadLine(), custom1);

        //CustomNode custom3 = new CustomNode(Console.ReadLine(), custom2);

        CustomNode target = root.Find(Console.ReadLine());

​

        Console.WriteLine(GetShortestUniqueQualifier(root, target));

    }

​

    public static string GetShortestUniqueQualifier(CustomNode root, CustomNode target)

    {

        // check if root and target exist

        if (root == null || target == null) return null;

​

        // check if target is root

        if (target == root) return target.Title;

​

        // check if target parent is root

        if (target.Parent == root){

            if (root.Title == target.Title) return root.Title + "/" + target.Title;

            else return target.Title;

        }

​

        // build the shortestUniqueQualifier string

        Stack<Tuple<string, bool>> suqStack = new Stack<Tuple<string, bool>>();

        suqStack.Push( new Tuple<string, bool>(target.Title, true) );

        CustomNode curr = target.Parent.Parent;

        bool found = false;

        while (curr != null){

            foreach (CustomNode c in curr.Children){

                if (c != target.Parent){

                    foreach (CustomNode d in c.Children){   

                        if (d.Title == target.Title){

                            found = true;

                            break;

                        }

                    }

                }

                if (found) break;

            }

            suqStack.Push( new Tuple<string, bool>(target.Parent.Title, found) );

            target = target.Parent;

            curr = curr.Parent;

            found = false;

        }

        string suqString = "";

        while (suqStack.Count > 0){

            var tempTuple = suqStack.Pop();

            if (tempTuple.Item2){

                suqString += tempTuple.Item1;

                while (suqStack.Count > 0) suqString += "/" + suqStack.Pop().Item1;

            }

        }

        // check if curr parent name same as curr name

        //if (target.Parent.Title == target.Title) return root.Title + "/" + suqString;

        return suqString;

    }

}

​