leetcode5944. 从二叉树一个节点到另一个节点每一步的方向(mid)(周赛)

力扣链接

题目描述

给你一棵 二叉树 的根节点 root ，这棵二叉树总共有 n 个节点。每个节点的值为 1 到 n 中的一个整数，且互不相同。给你一个整数 startValue ，表示起点节点 s 的值，和另一个不同的整数 destValue ，表示终点节点 t 的值。

请找到从节点 s 到节点 t 的 最短路径 ，并以字符串的形式返回每一步的方向。每一步用 大写 字母 'L' ，'R' 和 'U'分别表示一种方向：

'L' 表示从一个节点前往它的 左孩子 节点。
'R' 表示从一个节点前往它的 右孩子 节点。
'U' 表示从一个节点前往它的 父 节点。
请你返回从 s 到 t 最短路径 每一步的方向。

示例 1：

输入：root = [5,1,2,3,null,6,4], startValue = 3, destValue = 6
输出："UURL"
解释：最短路径为：3 → 1 → 5 → 2 → 6 。

示例 2：

输入：root = [2,1], startValue = 2, destValue = 1
输出："L"
解释：最短路径为：2 → 1 。

提示：

• 树中节点数目为 n 。
• 2 <= n <= 105
• 1 <= Node.val <= n
• 树中所有节点的值 互不相同 。
• 1 <= startValue, destValue <= n
• startValue != destValue

解题思路

第二次参加周赛，第一次写出三道题,虽然写出来了，但是都是比较暴力的解法，有很多待优化的地方

我的解题思路: 首先找出两个节点的最近公共父节点,然后在从该公共父节点去找那两个节点，并把路径放到集合中，肯定还是可以优化的，但是我想不出，找公共节点应该可以和添加路径合到一起。

代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    
    
    //最近公共祖先节点
    TreeNode ancestor;

    public String getDirections(TreeNode root, int startValue, int destValue) {
    
    
        dfs(root, startValue, destValue);
        
        List<String> list = new ArrayList<>();
        findNode(ancestor, startValue, list);
        List<String> list2 = new ArrayList<>();
        findNode(ancestor, destValue, list2);
        StringBuilder builder = new StringBuilder();
        //找startValue节点的路径只要知道节点个数即可，全部加"U"即可
        int size = list.size();
        for (int i = 0; i < size; i++) {
    
    
            builder.append("U");
        }
        
        //append寻找destValue的路径
        for (String s : list2) {
    
    
            builder.append(s);
        }

        return builder.toString();
    }

    //寻找最近公共父节点
    boolean dfs(TreeNode root, int startValue, int destValue) {
    
    
        if (root == null) {
    
    
            return false;
        }

        boolean lson = dfs(root.left, startValue, destValue);
        boolean rson = dfs(root.right, startValue, destValue);

        if (lson && rson || ((root.val == startValue || root.val == destValue) && (lson || rson))) {
    
    
            ancestor = root;
        }
        return lson || rson || root.val == startValue || root.val == destValue;
    }

    //添加路径
    boolean findNode(TreeNode root, int val, List<String> list) {
    
    
        if (root == null) {
    
    
            return false;
        }
        if (val == root.val) {
    
    
            return true;
        }
        list.add("L");
        boolean flag1 = findNode(root.left, val, list);
        if (flag1) {
    
    
            return true;
        }
        list.remove(list.size() - 1);
        list.add("R");
        boolean flag2 = findNode(root.right, val, list);
        if (flag2) {
    
    
            return true;
        }
        list.remove(list.size() - 1);
        return false;
    }
}

复杂度

复杂度不会算