给定一个二叉树，请你找出其中最长严格递增路径的长度。（提示：使用动态规划）

#include <iostream>
#include <algorithm> // 使用 c++ 中的 max() 函数
using namespace std;
// 定义二叉树节点类
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
public:
    int longestIncreasingPath(TreeNode* root) { // 求解最长递增路径长度
        if (!root) return 0; // 如果二叉树为空，返回 0
        int res = 1; // 记录最大路径长度
        dfs(root, res); // 计算最大路径长度
        return res; // 返回结果
    }
    int dfs(TreeNode* node, int& res) { // 计算节点作为父节点时的最大路径长度
        if (!node) return 0; // 如果该节点为空，返回 0
        // 计算左右子树中以其作为结尾的、连续严格递增的序列长度
        int left = dfs(node->left, res);
        int right = dfs(node->right, res);
        left = (node->left && node->left->val < node->val) ? left + 1 : 0; // 根据节点值判断更新 left
        right = (node->right && node->right->val < node->val) ? right + 1 : 0; // 根据节点值判断更新 right
        res = max(res, left + right); // 更新整个树中最大路径长度
        return max(left, right) + 1; // 返回以该节点作为结尾的最大路径长度
    }
};
int main() {
    // 创建一棵二叉树
    TreeNode* root = new TreeNode(1);
    TreeNode* node1 = new TreeNode(2);
    TreeNode* node2 = new TreeNode(3);
    TreeNode* node3 = new TreeNode(4);
    TreeNode* node4 = new TreeNode(5);
    root->left = node1;
    node1->left = node2;
    node1->right = node3;
    node3->right = node4;
    Solution s;
    int res = s.longestIncreasingPath(root); // 求解最长递增路径长度
    cout << res << endl; // 输出结果
    return 0;
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
class Solution {
    public int longestIncreasingPath(TreeNode root) { // 求解最长递增路径长度
        if (root == null) return 0; // 如果二叉树为空，返回 0
        int[] max = new int[]{1}; // 数组用于存储最大路径长度
        dfs(root, max); // 计算最大路径长度
        return max[0]; // 返回结果
    }
    private int dfs(TreeNode node, int[] max) { // 计算节点作为父节点时的最大路径长度
        if (node == null) return 0; // 如果该节点为空，返回 0
        // 计算左右子树中以其作为结尾的、连续严格递增的序列长度
        int left = dfs(node.left, max);
        int right = dfs(node.right, max);
        left = (node.left != null && node.left.val < node.val) ? left + 1 : 0; // 根据节点值判断更新 left
        right = (node.right != null && node.right.val < node.val) ? right + 1 : 0; // 根据节点值判断更新 right
        max[0] = Math.max(max[0], left + right); // 更新整个树中最大路径长度
        return Math.max(left, right) + 1; // 返回以该节点作为结尾的最大路径长度
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建一棵二叉树
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);
        TreeNode node3 = new TreeNode(4);
        TreeNode node4 = new TreeNode(5);
        root.left = node1;
        node1.left = node2;
        node1.right = node3;
        node3.right = node4;
        Solution s = new Solution();
        int res = s.longestIncreasingPath(root); // 求解最长递增路径长度
        System.out.println(res); // 输出结果
    }
}