wy的leetcode刷题记录_Day34

wy的leetcode刷题记录_Day34

时间：2022-11-5

1106. 解析布尔表达式

今天的每日一题是：1106. 解析布尔表达式

题目介绍

1. 给你一个以字符串形式表述的 布尔表达式（boolean） expression，返回该式的运算结果。

2. 有效的表达式需遵循以下约定：

   • “t”，运算结果为 True
   • “f”，运算结果为 False
   • “!(expr)”，运算过程为对内部表达式 expr 进行逻辑 非的运算（NOT）
   • “&(expr1,expr2,…)”，运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 与的运算（AND）
   • “|(expr1,expr2,…)”，运算过程为对 2 个或以上内部表达式 expr1, expr2, … 进行逻辑 或的运算（OR）

示例 1：
输入：expression = “!(f)”
输出：true

示例 2：
输入：expression = “|(f,t)”
输出：true

思路

首先思考这是一个简单的模拟题：题目的种类属于表达式处理类型，所以大体上应该使用栈来解决，仔细观察后发现我们只需要用栈将有用信息入栈后处理即可，其中“，”并没有什么用可以不用入栈，也可以入将其入栈后出栈的时候不加以处理就行，每当我们遇到一个右括号就说明一个表达式已经完全入栈，这个时候我们将其出栈，当遇到左括号时说明表达式完全出栈，然后再做一次出栈操作因为左括号前面是操作符，然后根据操作符的类型完成相应的算数，最后将结果入栈参与下一个表达式计算即可，最后栈中的元素就是f或者t就是答案啦。

代码

class Solution {
public:
    bool parseBoolExpr(string expression) {
        stack<char> Stack;
        int n=expression.size();
        for(int i=0;i<n;i++)
        {
            char temp=expression[i];
            if(temp==',')
            {
                continue;
            }
            else if(temp!=')')
            {
                Stack.push(temp);
            }
            else //if(temp==')')
            {
                int t=0;
                int f=0;
                char temp1=Stack.top();
                while(temp1!='(')
                {
                    Stack.pop();
                    if(temp1=='t')
                        t++;
                    else if(temp1=='f')
                        f++;
                    temp1=Stack.top();
                }
                Stack.pop();
                char op=Stack.top();
                switch(op)
                {
                    case '!':Stack.push(t==1?'f':'t');break;
                    case '&':Stack.push(f==0?'t':'f');break;
                    case '|':Stack.push(t>0?'t':'f');break;
                    default:break;
                }
            }
        }
        return Stack.top()=='t';
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

收获

巩固了堆栈知识，一看到表达式类题目一定想到堆栈！

429. N 叉树的层序遍历

429. N 叉树的层序遍历

题目介绍

1. 给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
2. 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]

示例 2：

输入：root =[1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]

思路

平常二叉树的层序遍历是每次在遍历某个层次时，遍历到某个节点将其值加入一个向量数组，顺便将其左右节点加入队列，而n叉树的子节点不止俩个，所以我们在每次遍历的时候要记录其子节点个数并将其放入队列就可以了。
如果是用DFS做的话，首先这道题用前序、中序、后序遍历都可，但是你需要维护这个节点所在的层数，根据层数将其放入一个二维的vector。

代码

bfs

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> qu;
        vector<vector<int>> ans;
        if(root==nullptr)
            return ans;
        Node* node=root;
        qu.push(root);
        while(!qu.empty())
        {
            vector<int> sub_ans;
            int n=qu.size();
            for(int i=0;i<n;i++)
            {
                node=qu.front();
                qu.pop();
                sub_ans.push_back(node->val);
                for (Node* child: node->children) {
                    qu.push(child);
                }
            }
            ans.push_back(sub_ans);
        }
        return ans;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

dfs

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        vector<vector<int>> ans;
        dfs(root,0,ans);
        return ans;
    }
    void dfs(Node* node,int depth,vector<vector<int>> &ans)
    {
        if(node==nullptr)
        {
            return ;
        }
        if(depth<ans.size())
        {
            ans[depth].push_back(node->val);
        }
        else
        {
            ans.push_back({node->val});
        }
        
        for(auto child:node->children)
        {
            dfs(child,depth+1,ans);
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

收获

DFS和BFS知识点一点一点累计，直到形成记忆！！