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.

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);
    }
}

*lintcode578- Lowest Common Ancestor III- medium