*lintcode578- Lowest Common Ancestor III- medium

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.

Notice

node A or node B may not exist in tree.

Example

For the following binary tree:

  4
 / 
3   7
   / 
  5   6

LCA(3, 5) = 4

LCA(5, 6) = 7

LCA(6, 7) = 7

 

最普适的版本。用resultType作为辅助，包含hasA,hasB,和node。和一开始的方法完全没有区别，只是要一层层把整棵树里面有没有AB的信息返到最顶层，从而最顶层调用helper的时候根据有没有AB来判断这个node能不能用（有AB则是正确的LCA，没有AB则只是把A或者B返了上来）。

/**
 * 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.
     */
     
    private class ResultType{
        public boolean hasA, hasB;
        public 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) {
        // write your code here
        ResultType result = findNode(root, A, B);
        if (result.hasA && result.hasB) {
            return result.node;
        }
        return null;
    }
    
    //ding yi定义
    //1. if has A, set hasA
    //2. if has B, set hasB
    //3. if (left.hasA&&right.hasB) || (left.hasB&&right.hasA) lca = root;
    private ResultType findNode(TreeNode root, TreeNode A, TreeNode B) {
        
        if (root == null) {
            return new ResultType(false, false, null);
        }
        
        ResultType left = findNode(root.left, A, B);
        ResultType right = findNode(root.right, A, B);
        
        boolean crtHasA = left.hasA || right.hasA || root == A;
        boolean crtHasB = left.hasB || right.hasB || root == B;
        
        if (root == A || root == B) {
            return new ResultType(crtHasA, crtHasB, root);
        }
        
        
        if (left.node != null && right.node != null) {
            return new ResultType(crtHasA, crtHasB, root);
        }
        
        if (left.node != null) {
            return new ResultType(crtHasA, crtHasB, left.node);
        }
        
        if (right.node != null) {
            return new ResultType(crtHasA, crtHasB, right.node);
        }
        
        return new ResultType(crtHasA, crtHasB, null);
    }
}