2021-01-21

最新推荐文章于 2021-08-11 16:36:42 发布

原创最新推荐文章于 2021-08-11 16:36:42 发布 · 82 阅读

CC 4.0 BY-SA版权

这篇博客探讨了两种不同的算法问题：第一种是寻找树结构中节点的最大路径和，采用递归策略更新最大路径和；第二种是求解股票价格的最大收益，通过动态规划和双指针方法实现。这两种算法都涉及到了数值优化和决策制定。

class Solution {
    int maxSum = Integer.MIN_VALUE;

    public int maxPathSum(TreeNode root) {
        maxGain(root);
        return maxSum;
    }

    public int maxGain(TreeNode node) {
        if (node == null) {
            return 0;
        }
        
        // 递归计算左右子节点的最大贡献值
        // 只有在最大贡献值大于 0 时，才会选取对应子节点
        int leftGain = Math.max(maxGain(node.left), 0);
        int rightGain = Math.max(maxGain(node.right), 0);

        // 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值
        int priceNewpath = node.val + leftGain + rightGain;

        // 更新答案
        maxSum = Math.max(maxSum, priceNewpath);

        // 返回节点的最大贡献值
        return node.val + Math.max(leftGain, rightGain);
    }
}

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int[][] dp = new int[n][2];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < n; ++i) {
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }
        return dp[n - 1][0];
    }
}

class Solution {
    public int maxProfit(int[] prices) {
     if (prices.length == 0)
				return 0;
			int max = 0;
			int low = prices[0];
			for (int i = 1; i < prices.length; i++)
			{
				if ((prices[i] - low) > max)
				{
					max = prices[i] - low;
				}
				if (prices[i] < low)
				{
					low = prices[i];
				}
			}
			return max;
    }
}