k distance

    public List<Integer> distanceK(TreeNode root, TreeNode target, int K) {
        ParentedTreeNode parentedTreeNode = constructParentedTree(root);

        List<Integer> distanceK = distanceK(parentedTreeNode, target.val, K);

        return distanceK;
    }

    private List<Integer> distanceK(ParentedTreeNode treeNode, int val, int k) {
        ParentedTreeNode target = FindTargetNode(treeNode, val);
        List<Integer> distanceK = distanceK(target, k);
        return distanceK;
    }

    private List<Integer> distanceK(ParentedTreeNode target, int K) {
        List<Integer> result = new ArrayList<>();
        Queue<ParentedTreeNode> q = new LinkedList<>();
        Queue<Integer> qk = new LinkedList<>();
        q.add(target);
        qk.add(K);
        while (!q.isEmpty()) {
            ParentedTreeNode node = q.remove();
            int k = qk.remove();
            if (k == 0) {
                result.add(node.val);
                continue;
            }
            if (node.left != null) {
                node.left.parent = null;
                q.add(node.left);
                qk.add(k - 1);
            }
            if (node.right != null) {
                node.right.parent = null;
                q.add(node.right);
                qk.add(k - 1);
            }
            if (node.parent != null) {
                if (node.parent.right != null && node.parent.right.val == node.val)
                    node.parent.right = null;
                else
                    node.parent.left = null;
                q.add(node.parent);
                qk.add(k - 1);
            }
        }

        return result;
    }

    private ParentedTreeNode FindTargetNode(ParentedTreeNode treeNode, int val) {
        Queue<ParentedTreeNode> q = new LinkedList<>();
        q.add(treeNode);
        while (!q.isEmpty()) {
            ParentedTreeNode node = q.remove();
            if (node.val == val)
                return node;
            if (node.left != null)
                q.add(node.left);
            if (node.right != null)
                q.add(node.right);
        }
        return null;
    }

    private ParentedTreeNode constructParentedTree(TreeNode root) {
        Queue<TreeNode> qt = new LinkedList<>();
        Queue<ParentedTreeNode> qpt = new LinkedList<>();

        qt.add(root);
        ParentedTreeNode rootqpt = new ParentedTreeNode(root.val);
        qpt.add(rootqpt);
        while (!qt.isEmpty()) {
            TreeNode nodeT = qt.remove();
            ParentedTreeNode nodePT = qpt.remove();
            if (nodeT.left != null) {
                qt.add(nodeT.left);
                nodePT.left = new ParentedTreeNode(nodeT.left.val);
                nodePT.left.parent = nodePT;
                qpt.add(nodePT.left);
            }
            if (nodeT.right != null) {
                qt.add(nodeT.right);
                nodePT.right = new ParentedTreeNode(nodeT.right.val);
                nodePT.right.parent = nodePT;
                qpt.add(nodePT.right);
            }
        }
        return rootqpt;
    }

    public static TreeNode stringToTreeNode(String input) {
        input = input.trim();
        input = input.substring(1, input.length() - 1);
        if (input.length() == 0) {
            return null;
        }

        String[] parts = input.split(",");
        String item = parts[0];
        TreeNode root = new TreeNode(Integer.parseInt(item));
        Queue<TreeNode> nodeQueue = new LinkedList<>();
        nodeQueue.add(root);

        int index = 1;
        while (!nodeQueue.isEmpty()) {
            TreeNode node = nodeQueue.remove();

            if (index == parts.length) {
                break;
            }

            item = parts[index++];
            item = item.trim();
            if (!item.equals("null")) {
                int leftNumber = Integer.parseInt(item);
                node.left = new TreeNode(leftNumber);
                nodeQueue.add(node.left);
            }

            if (index == parts.length) {
                break;
            }

            item = parts[index++];
            item = item.trim();
            if (!item.equals("null")) {
                int rightNumber = Integer.parseInt(item);
                node.right = new TreeNode(rightNumber);
                nodeQueue.add(node.right);
            }
        }
        return root;
    }

    public static String integerArrayListToString(List<Integer> nums, int length) {
        if (length == 0) {
            return "[]";
        }

        String result = "";
        for (int index = 0; index < length; index++) {
            Integer number = nums.get(index);
            result += Integer.toString(number) + ", ";
        }
        return "[" + result.substring(0, result.length() - 2) + "]";
    }

    public static String integerArrayListToString(List<Integer> nums) {
        return integerArrayListToString(nums, nums.size());
    }

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String line;
        while ((line = in.readLine()) != null) {
            TreeNode root = stringToTreeNode(line);
            line = in.readLine();
            TreeNode target = stringToTreeNode(line);
            line = in.readLine();
            int K = Integer.parseInt(line);

            List<Integer> ret = new AllNodesDistanceKinBinaryTree().distanceK(root, target, K);

            String out = integerArrayListToString(ret);

            System.out.print(out);
        }
    }

    public class ParentedTreeNode {
        int val;
        ParentedTreeNode left;
        ParentedTreeNode right;
        ParentedTreeNode parent;

        ParentedTreeNode(int x) {
            val = x;
        }
    }