Lowest Common Ancestor III

Given the root and two nodes in a Binary Tree. Find the lowest common ancestor(LCA) of the two nodes.
The lowest common ancestor is the node with largest depth which is the ancestor of both nodes.
Return null if LCA does not exist.

Example

Example1

Input: 
{4, 3, 7, #, #, 5, 6}
3 5
5 6
6 7 
5 8
Output: 
4
7
7
null
Explanation:
  4
 / \
3   7
   / \
  5   6

LCA(3, 5) = 4
LCA(5, 6) = 7
LCA(6, 7) = 7
LCA(5, 8) = null

Example2

Input:
{1}
1 1
Output: 
1
Explanation:
The tree is just a node, whose value is 1.

Notice

node A or node B may not exist in tree.
Each node has a different value

思路：用hasA，hasB，node来表示resultType，node表示找到的可能的candidate，并不是表示commonNode，因为最后还要判断A,B 同时存在的情况下，才返回node

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */


public class Solution {
    /*
     * @param root: The root of the binary tree.
     * @param A: A TreeNode
     * @param B: A TreeNode
     * @return: Return the LCA of the two nodes.
     */
    class ResultType {
        boolean hasA;
        boolean hasB;
        TreeNode node;
        public ResultType(boolean hasA, boolean hasB, TreeNode node) {
            this.hasA = hasA;
            this.hasB = hasB;
            this.node = node;
        }
    }
    public TreeNode lowestCommonAncestor3(TreeNode root, TreeNode A, TreeNode B) {
        if(root == null) return null;
        ResultType resultType = LCAHelper(root, A, B);
        if(resultType.hasA && resultType.hasB) {
            return resultType.node;
        } else {
            return null;
        }
    }
    
    private ResultType LCAHelper(TreeNode root, TreeNode A, TreeNode B) {
        if(root == null) {
            return new ResultType(false, false, null);
        }
        
        ResultType leftRes = LCAHelper(root.left, A, B);
        ResultType rightRes = LCAHelper(root.right, A, B);
        
        boolean hasA = leftRes.hasA || rightRes.hasA || root == A;
        boolean hasB = leftRes.hasB || rightRes.hasB || root == B;
        
        if(root == A || root == B) {
            return new ResultType(hasA, hasB, root);
        }
        
        if(leftRes.node != null && rightRes.node != null) {
            return new ResultType(hasA, hasB, root);
        }
        
        if(leftRes.node != null) {
            return new ResultType(hasA, hasB, leftRes.node);
        }
        
        if(rightRes.node != null) {
            return new ResultType(hasA, hasB, rightRes.node);
        }
        
        return new ResultType(hasA, hasB, null);
    }
}