寒假刷题打卡第二十二 & 第二十三天

本文链接：https://blog.csdn.net/hughlee815/article/details/114074889

为运算表达式设计优先级（加括号）
我完全想不出这样的解法。
这道题给我的启发是，递归可以从自下而上和自上而下两个角度去想。之前做二叉树相关的题目，大多是自下而上。
而自上而下的递归有个更好听的名字，叫分而治之。

class Solution {
public:
    vector<int> diffWaysToCompute(string input) {
        vector<int> vec1, vec2, res;
        int n = input.size();
        int flag = 0;
        for(int i=0; i<n; i++){
            if(input[i] == '+' || input[i] == '-' || input[i] == '*'){  //不是这三个符号必然就是数字，避免写函数判断是否是数字
                flag = 1; // flag=1说明string是表达式，flag=0说明string是一个数字
                vec1 = diffWaysToCompute(string(input, 0, i)); // 从第0个开始，存i个字符
                vec2 = diffWaysToCompute(string(input, i+1, n-i-1));  //竟然C++也能这样切片，我还不知道
                for(int v1:vec1){
                    for(int v2:vec2){
                        if(input[i] == '+') res.push_back(v1+v2);
                        if(input[i] == '-') res.push_back(v1-v2);
                        if(input[i] == '*') res.push_back(v1*v2);
                    }
                }
            }
        }
        if(flag==0) return {std::stoi(input)};  //stoi
        return res;
    }
};

不同的二叉搜索树 II
暂时没想出来，但是我应该能想出来。暂搁一段时间

以下是搜索的内容

BFS
每一层遍历的节点都与根节点距离相同。设 di 表示第 i 个节点与根节点的距离，推导出一个结论：对于先遍历的节点 i 与后遍历的节点 j，有 di <= dj。利用这个结论，可以求解最短路径等最优解问题：第一次遍历到目的节点，其所经过的路径为最短路径。应该注意的是，使用 BFS 只能求解无权图的最短路径，无权图是指从一个节点到另一个节点的代价都记为 1。

在程序实现 BFS 时需要考虑以下问题：

队列：用来存储每一轮遍历得到的节点；
标记：对于遍历过的节点，应该将它标记，防止重复遍历。
3. 二进制矩阵中的最短路径
 答案给了一个BFS模板，真良心。但是速度为啥这么慢呢？
4. 完全平方数
答案都看不懂。
5. 单词接龙
虽然只击败了5%，但怎么说也是我自己独立完成的第一道困难题。
其实就是按照BFS的模板来，但是难点在于怎么建模这个图问题。
本题要求的是最短转换序列的长度，看到最短首先想到的就是广度优先搜索。

答案有更好的解法，二刷的时候再来看吧。

DFS
从一个节点出发，使用 DFS 对一个图进行遍历时，能够遍历到的节点都是从初始节点可达的，DFS 常用来求解这种 可达性 问题。
在程序实现 DFS 时需要考虑以下问题：

栈：用栈来保存当前节点信息，当遍历新节点返回时能够继续遍历当前节点。可以使用递归栈。
标记：和 BFS 一样同样需要对已经遍历过的节点进行标记。

岛屿的最大面积
就这？
我维护了一个visited数组，看了答案，其实可以不用：访问了某个元素就把该元素设置为0就好了。

class Solution {
public:
    
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        if(grid.size()==0 || grid[0].size()==0)
            return 0;
        int rows = grid.size();
        int cols = grid[0].size();
        vector<int> temp(cols, 0);
        vector<vector<int>> visited(rows, temp);
        int ans = 0;
        for(int i=0; i<rows; i++)
            for(int j=0; j<cols; j++)
            {
                int locMax = 0;
                dfs(grid, i, j, locMax, visited, rows, cols);
                ans = max(locMax, ans);
            }
        return ans;
    }

    void dfs(vector<vector<int>>& grid, int i, int j, int& locMax, vector<vector<int>>& visited, int rows, int cols)
    {
        if(i<0 || i>=rows || j<0 || j>=cols || visited[i][j] || !grid[i][j])
            return;
        visited[i][j]=1;
        locMax++;
        dfs(grid, i-1, j, locMax, visited, rows, cols);
        dfs(grid, i+1, j, locMax, visited, rows, cols);
        dfs(grid, i, j-1, locMax, visited, rows, cols);
        dfs(grid, i, j+1, locMax, visited, rows, cols);
    }
};

矩阵中连通分量数目
和上一题思路完全一样。
懒得贴代码。
省份数量
学到了!!
但是一定要记住，传递visited的时候要用引用呀！！！！！
被围绕的区域
一次性提交通过而且几乎双百的感觉确实很爽。

    void dfs(vector<vector<char>>& board, int i, int j)
    {
        if(i<0 || i>=board.size() || j<0 || j>=board[0].size() || board[i][j]!='O')  //这个地方，bug多发区。一定是大于等于
            return;
        board[i][j]='o';
        dfs(board, i-1, j);
        dfs(board, i+1, j);
        dfs(board, i, j-1);
        dfs(board, i, j+1);
    }