add binary tree maximum path sum

algorithms/cpp/binary_tree_maximum_path_sum.cpp

@@ -0,0 +1,85 @@
+/* Problem Statement ->
+A path in a binary tree is a sequence of nodes where each pair of adjacent nodes in the sequence has an edge connecting them. A node can only appear in the sequence at most once. Note that the path does not need to pass through the root.
+The path sum of a path is the sum of the node's values in the path. Given the root of a binary tree, return the maximum path sum of any non-empty path.
+
+Example 1:
+Input: root = [1,2,3]
+Output: 6
+Explanation: The optimal path is 2 -> 1 -> 3 with a path sum of 2 + 1 + 3 = 6.
+
+Example 2:
+Input: root = [-10,9,20,null,null,15,7]
+Output: 42
+Explanation: The optimal path is 15 -> 20 -> 7 with a path sum of 15 + 20 + 7 = 42.
+
+Constraints:
+The number of nodes in the tree is in the range [1, 3 * 104].
+-1000 <= Node.val <= 1000
+*/
+
+/* Code -> */
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+
+#include <iostream>
+#include <algorithm>
+#include <climits> // Add this include for INT_MIN
+
+using namespace std;
+
+// Definition for a binary tree node.
+struct TreeNode {
+    int val;
+    TreeNode* left;
+    TreeNode* right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+public:
+    int maxPathSum(TreeNode* root) {
+        int maxSum = INT_MIN;
+        calculateMaxPathSum(root, maxSum);
+        return maxSum;
+    }
+
+    int calculateMaxPathSum(TreeNode* node, int& maxSum) {
+        if (!node) return 0;
+
+        int leftMax = max(0, calculateMaxPathSum(node->left, maxSum));
+        int rightMax = max(0, calculateMaxPathSum(node->right, maxSum));
+
+        maxSum = max(maxSum, node->val + leftMax + rightMax);
+
+        return node->val + max(leftMax, rightMax);
+    }
+};
+
+int main() {
+    // Example 1
+    TreeNode* root1 = new TreeNode(1);
+    root1->left = new TreeNode(2);
+    root1->right = new TreeNode(3);
+    Solution solution;
+    cout << "Example 1: " << solution.maxPathSum(root1) << endl;
+
+    // Example 2
+    TreeNode* root2 = new TreeNode(-10);
+    root2->left = new TreeNode(9);
+    root2->right = new TreeNode(20);
+    root2->right->left = new TreeNode(15);
+    root2->right->right = new TreeNode(7);
+    cout << "Example 2: " << solution.maxPathSum(root2) << endl;
+
+    return 0;
+}