[Leetcode] 每日两题 124 210 -day109

这段时间重温一下C++编程

124. 二叉树中的最大路径和

深度优先搜索

维护一个全局最优值，对于每个节点其可能最大值 在（节点值 ，以及左右子节点是否选择）中

但是题目要求的是路径 而不是子树 （需要注意）

所以对于 某个父节点 选择该子节点的 最优值时 需要排除 其子节点左右都连接的情况，

所以递归的返回和最大值的维护稍有不同

class Solution:
    
    def maxPathSum(self, root: Optional[TreeNode]) -> int:
        res = -1000
        def dfs(node):
            nonlocal res
            if not node :
                return -1000
            tmpl,tmpr = dfs(node.left),dfs(node.right)
            res = max(res,node.val,node.val+tmpl,node.val+tmpr,node.val+tmpl+tmpr)

            return max(node.val,node.val+tmpl,node.val+tmpr)

        dfs(root)
        return res

class Solution {
public:
    int res = -1000;
    int dfs(TreeNode* node){
        if(node==NULL)return -1000;
        int tmpl ,tmpr,ret;
        tmpl= dfs(node->left);
        tmpr= dfs(node->right);
        
        ret = max(max(node->val,node->val+tmpl),node->val+tmpr);
        res = max(res,max(ret ,node->val+tmpr+tmpl));
        return  ret;
    }
    int maxPathSum(TreeNode* root) {
        dfs(root);
        return res ;
    }
};

210. 课程表 II

和课程表Ⅰ类似 ，一模一样的方法 就是需要保存一下队列弹出的元素。
https://blog.csdn.net/weixin_43146899/article/details/123364365?spm=1001.2014.3001.5502

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        shl = [0]*numCourses
        lis = [[]for _ in range(numCourses)]  
        for  x,y in prerequisites:
            lis[y].append(x)       # 有课程y  是课程x的先决课程
            shl[x]+=1

        que = []
        for i in range(numCourses):
            if shl[i] ==0:
                que.append(i)
        res = []
        while que:
            x = que.pop()
            res.append(x)
            for i in lis[x]:
                shl[i] -=1
                if shl[i]==0:
                    que.append(i)
        if len(res) ==numCourses:
            return  res
        return []

class Solution {
public:
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {
        vector<int> num(numCourses,0);
        vector<vector<int>> lis(numCourses);

        for (auto &pre :prerequisites){
            num[pre[0]]++;
            lis[pre[1]].push_back(pre[0]);
        }
        queue<int> q;
        for(int i =0;i<numCourses;i++){
            if (num[i]==0)
                q.push(i);
        }
        vector<int> res;
        while (!q.empty()){
            int x = q.front();
            q.pop();
            res.push_back(x);
            for (auto &i :lis[x]){
                num[i]--;
                if (num[i]==0)
                    q.push(i);
            }
        }
        if(res.size()==numCourses)
            return res;
        return vector<int>{};
    }
};