leetcode1372

class Solution {
    int maxpath = 0;
    HashMap<TreeNode, Integer> map1 = new HashMap<TreeNode, Integer>();
    HashMap<TreeNode, Integer> map2 = new HashMap<TreeNode, Integer>();

    public void preOrder(TreeNode node) {
        if (node != null) {
            int leftpath = getTreePath(node, 0, 0);
            int rightpath = getTreePath(node, 1, 0);
            maxpath = Math.max(maxpath, Math.max(leftpath, rightpath));

            preOrder(node.left);
            preOrder(node.right);
        }
    }

    public int getTreePath(TreeNode node, int direction, int pathsum) {
        if (node == null) {
            return 0;
        } else {
            if (direction == 0) {// 向左
                if (map1.containsKey(node)) {
                    return pathsum + map1.get(node);
                } else {
                    pathsum = getTreePath(node.left, 1, pathsum) + 1;
                    map1.put(node, pathsum);
                    return pathsum;
                }
            } else {// 向右
                if (map2.containsKey(node)) {
                    return pathsum + map2.get(node);
                } else {
                    pathsum = getTreePath(node.right, 0, pathsum) + 1;
                    map2.put(node, pathsum);
                    return pathsum;
                }
            }
        }

    }

    public int longestZigZag(TreeNode root) {
        preOrder(root);
        return maxpath - 1;
    }
}

算法思路：二叉树遍历+备忘录缓存。

maxpath记录全局最大的蛇形走位的路径长度，map1记录从某个节点开始左向的最大长度(缓存)，map2记录从某个节点开始右向的最大长度(缓存)。

使用某序遍历整个输，对每一个节点，依次执行左向走法和右向走法，并更新最大全局路径(第10行)。

 注意22行和30行，分别是用缓存加速查询，如果之前已经查询过的节点，就直接返回。