一周Hard (2021.11.26-2021.11.28)

124. 二叉树中的最大路径和
考虑以每个点为必经点的最大路径和，即$dfs$每个点
找到其左子树和右子树最大值，注意，最大值还需大于$0$才对答案有正贡献。
最后选取和最大的一条链返回，如果左右子树最大值均小于$0$，则可以不选取左右子树。

/**
 * 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) {}
 * };
 */
class Solution {
    
    
public:
    
    int res = -1e9;
    
    int dfs(TreeNode* root) {
    
    
        if(root == nullptr) return 0;
        int left = max(0, dfs(root->left));
        int right = max(0, dfs(root->right));
        int sum = root->val;
        res = max(res, sum + left + right);
        int temp = left;
        if(right > temp) temp = right;
        if(temp > 0) sum += temp;
        return sum;
    }
    
    int maxPathSum(TreeNode* root) {
    
    
        dfs(root);
        return res;
    }
};

827. 最大人工岛
好像并没有什么值得hard的地方，如果有，也许是码量吧。
因为想做到时间尽可能低，就没并查集，直接bfs其实更简单
然后再枚举每个$0$点的四个方向，注意去重就行

class Solution {
    
    
public:
    
    int tot, n, m;
    vector<int> cnt;
    vector<vector<int>> p;
    
    int dx[4] = {
    
    -1, 0, 1, 0};
    int dy[4] = {
    
    0, 1, 0, -1};
    
    int largestIsland(vector<vector<int>>& grid) {
    
    
        tot = 0;
        n = grid.size();
        m = grid[0].size();
        cnt = vector<int>(1);
        p = vector<vector<int>> (n, vector<int>(m, 0));
        vector<pair<int, int>> q(n * m);
        
        int ans = 0;
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < m; ++j)
                if(grid[i][j] == 1 && p[i][j] == 0) {
    
    
                    tot += 1;
                    p[i][j] = tot;
                    int hh = 0, tt = -1;
                    q[++tt] = make_pair(i, j);
                    while(hh <= tt) {
    
    
                        auto u = q[hh++];
                        for(int k = 0; k < 4; ++k) {
    
    
                            int nx = u.first + dx[k], ny = u.second + dy[k];
                            if(nx >= 0 && nx < n && ny >= 0 && ny < m && grid[nx][ny] == 1 && p[nx][ny] == 0) {
    
    
                                q[++tt] = make_pair(nx, ny);
                                p[nx][ny] = tot;
                            }
                        }
                    }
                    
                    cnt.push_back(tt + 1);
                    ans = max(ans, tt + 1);
                }
        
        for(int i = 0; i < n; ++i)
            for(int j = 0; j < m; ++j)
                if(grid[i][j] == 0) {
    
    
                    vector<int> temp;
                    for(int k = 0; k < 4; ++k) {
    
    
                        int nx = i + dx[k], ny = j + dy[k];
                        if(nx >= 0 && nx < n && ny >= 0 && ny < m && p[nx][ny] != 0) {
    
    
                            temp.push_back(p[nx][ny]);
                        }
                    }
                    sort(temp.begin(), temp.end());
                    temp.erase(unique(temp.begin(), temp.end()), temp.end());
                    
                    int res = 1;
                    for(auto u : temp) res += cnt[u];
                    
                    ans = max(ans, res);
                }
        
        return ans;
    }
};

44. 通配符匹配
算是较高难度的$dp$了，之后补思路