面试算法总结:动态规划3

这里再来两个动态规划的经典题目。
题目一：一维数组的最大连续子序列。
这哥可以说是动态规划入门了，主要就是运用了*‘0’*，这个不多说，直接上代码。

int max = Integer.MIN_VALUE;
dp[0] = a[0]; 
for(int i=1;i<n;i++){
    if(dp[i-1]<0){
        dp[i] = a[i];
    }else{
        dp[i] = dp[i-1]+a[i];
    }
    max = Math.max(dp[i],max);
}
return max;

这个很简单，不多说，下面说说升级版:树上的最大路径。
题目连接在这里
二叉树中的最大路径和 leetcode 124
AC代码如下：

	//二叉树建树，可以理解为层次遍历建树
    void buildTree(){
        TreeNode node = new TreeNode(a[0]);
        build(a, node, 0);
    }

    public void build(int[] x, TreeNode node, int pos) {
        if (pos >= x.length)
            return;
        if (2 * pos + 1 < x.length) {
            TreeNode left = new TreeNode(x[2 * pos + 1]);
            node.left = left;
            build(x, left, 2 * pos + 1);
        }
        if (2 * pos + 2 < x.length) {
            TreeNode right = new TreeNode(x[2 * pos + 2]);
            node.right = right;
            build(x, right, 2 * pos + 2);
        }
    }

    public int maxPathSum(TreeNode root) {
        if (root == null)
            return 0;
        dfs(root);
        return maxi;
    }

    int maxi = Integer.MIN_VALUE;

    private int dfs(TreeNode root) {
        if (root == null)
            return 0;
        int left = 0, right = 0;
        if (root.left != null) {
            left = dfs(root.left);
        }
        if (root.right != null) {
            right = dfs(root.right);
        }
        int returnVal = root.val;
        int leftV = left + root.val;
        int rightV = right + root.val;
        returnVal = Math.max(returnVal, leftV);
        returnVal = Math.max(returnVal, rightV);
        maxi = Math.max(maxi, returnVal);
        maxi = Math.max(maxi, left + right + root.val);
        return returnVal < 0 ? 0 : returnVal;//这里注意返回时，路径要连续
    }