CSP历年复赛题-P7073 [CSP-J2020] 表达式

原题链接：https://www.luogu.com.cn/problem/P7073

题意解读：给定一个后缀表达式，其中变量都有初始值，q个询问，每次将一个变量取反，求后缀表达式的结果。

解题思路：

1、堆栈模拟法

我们知道，对于后缀表达式，可以借助堆栈进行运算，依次读取操作数和操作符，如果是操作数则入栈，如果是操作符则弹出栈顶1-2个元素进行运算（& |需要两个操作数，!只要一个操作数），运算结果再次入栈，最后栈顶即为表达式结果。

由于表达式最长10^6，q最大10^5，超时是一定的。

那么问题就集中在字符串处理，具体看代码。

30分代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 100005;
string str;
int n, q;
int x[N];

int main()
{
    getline(cin, str);
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> x[i]; //所有变量初始值

    int t;
    cin >> q;
    while(q--)
    {
        cin >> t;
        //变量取反
        x[t] = !x[t];
        //后缀表达式计算
        stack<int> stk;
        for(int i = 0; i < str.length(); i++)
        {
            if(str[i] == 'x')
            {
                int num = 0;
                int j = i + 1; //读变量x后面的数字
                while(str[j] >= '0' && str[j] <= '9')
                {
                    num = num * 10 + str[j] - '0';
                    j++;
                }
                stk.push(x[num]); //变量值入栈
                i = j - 1;
            }
            else if(str[i] == '&')
            {
                int a = stk.top(); stk.pop();
                int b = stk.top(); stk.pop();
                int c = a & b;
                stk.push(c);
            }
            else if(str[i] == '|')
            {
                int a = stk.top(); stk.pop();
                int b = stk.top(); stk.pop();
                int c = a | b;
                stk.push(c);
            }
            else if(str[i] == '!')
            {
                int a = stk.top(); stk.pop();
                int c = !a;
                stk.push(c);
            }
        }
        cout << stk.top() << endl;
        //变量恢复
        x[t] = !x[t];
    }
}

2、表达式树

对于任何一个中缀表达式，都可以转化为一棵树形结构，如样例中：

x1 x2 & x3 | 对应的中缀表达式为 x1 & x2 | x3

转化为树形结构为：

可以看出，变量都是叶子节点，操作符都是中间节点或根节点，根节点的值就是表达式的值。

接下来要解决三个关键问题：

第一、如何构建表达式树？

通过堆栈计算后缀表达式的过程，可以提取出变量和操作符，变量编号是树中的节点，操作符编号（在最大变量编号基础上递增）也是树中的节点，计算之后的结果关联在操作符节点上，如此最终就能构建出一棵树，最后栈顶的元素就是根节点。

由于&/|的子节点有两个，！的子节点只有一个，可以直接采用邻接表来存储树形结构。

    cnt = n; //节点编号跳过变量编号
    for(int i = 0; i < str.length(); i++)
    {
        if(str[i] == 'x')
        {
            int num = 0;
            int j = i + 1; //读变量x后面的数字
            while(str[j] >= '0' && str[j] <= '9')
            {
                num = num * 10 + str[j] - '0';
                j++;
            }
            stk.push(num); //变量编号入栈
            i = j - 1;
        }
        else if(str[i] == '&' || str[i] == '|')
        {
            int a = stk.top(); stk.pop();
            int b = stk.top(); stk.pop();
            cnt++; //符号节点累加
            stk.push(cnt); //符号节点编号入栈
            tree[cnt].push_back(a); //节点cnt和a之间建立一条边
            tree[cnt].push_back(b); //节点cnt和b之间建立一条边
            o[cnt] = str[i];
        }
        else if(str[i] == '!')
        {
            int a = stk.top(); stk.pop();
            cnt++;
            stk.push(cnt);
            tree[cnt].push_back(a);
            o[cnt] = '!';
        }
    }

第二、如何计算树中每个节点的值？

从根节点出发，通过递归对所有子树的值，用操作符进行计算。

int dfs1(int root)
{
    if(root <= n) return v[root]; //变量叶子节点直接返回变量值
    if(o[root] == '&') return v[root] = dfs1(tree[root][0]) & dfs1(tree[root][1]);
    if(o[root] == '|') return v[root] = dfs1(tree[root][0]) | dfs1(tree[root][1]);
    if(o[root] == '!') return v[root] = !dfs1(tree[root][0]);
}

第三、将某个叶子节点的值取反，根节点的值是否改变？

如果每次都将某个叶子节点值取反，然后利用dfs1重新算一次表达式的值，事件复杂度也是nq。

其实，只需要计算一次初始表达式的值dfs1

然后需要看哪些变量的变化会影响表达式的值即可，如果影响则表达式的值取反，如果不影响表达式的值不变。

如何来标记哪些变量的变化会影响结果呢？

我们引入dfs2，核心思想是从根节点出发，标记每个对结果能产生影响的节点

如果当前符号是&，如果左子树是1，则标记右子树会对结果产生影响，反之如果右子树是1，则标记左子树会对结果产生影响；

如果当前符号是|，如果左子树是0，则标记右子树会对结果产生影响，反之如果右子树是0，则标记左子树会对结果产生影响；

如果当前符号是!，则标记子节点会对结果产生影响。

void dfs2(int root)
{
    flag[root] = true;
    if(o[root] == '&')
    {
        if(v[tree[root][0]] == 1) dfs2(tree[root][1]); //如果左子树值是1，则标记右子树的值会影响表达式结果
        if(v[tree[root][1]] == 1) dfs2(tree[root][0]); //如果右子树值是1，则标记左子树的值会影响表达式结果
    }
    if(o[root] == '|')
    {
        if(v[tree[root][0]] == 0) dfs2(tree[root][1]); //如果左子树结果是0，则标记右子树的值会影响表达式结果
        if(v[tree[root][1]] == 0) dfs2(tree[root][0]); //如果右子树结果是0，则标记左子树的值会影响表达式结果
    }
    if(o[root] == '!') dfs2(tree[root][0]); //子树的值肯定影响结果
}

100分代码：

#include <bits/stdc++.h>
using namespace std;

const int N = 1000005; //树的节点比变量数多，但肯定不超过10^6
string str;
int n, q, cnt;
vector<int> tree[N]; 
char o[N]; //树中每个节点对应的操作符，如果有
int v[N]; //树中每个节点的值
stack<int> stk;
bool flag[N]; //标记某个变量的值的变化是否影响最终的结果

//计算表达式的值
int dfs1(int root)
{
    if(root <= n) return v[root]; //变量叶子节点直接返回变量值
    if(o[root] == '&') return v[root] = dfs1(tree[root][0]) & dfs1(tree[root][1]);
    if(o[root] == '|') return v[root] = dfs1(tree[root][0]) | dfs1(tree[root][1]);
    if(o[root] == '!') return v[root] = !dfs1(tree[root][0]);
}

//标记所有节点的变化会影响表达式的结果
void dfs2(int root)
{
    flag[root] = true;
    if(o[root] == '&')
    {
        if(v[tree[root][0]] == 1) dfs2(tree[root][1]); //如果左子树值是1，则标记右子树的值会影响表达式结果
        if(v[tree[root][1]] == 1) dfs2(tree[root][0]); //如果右子树值是1，则标记左子树的值会影响表达式结果
    }
    if(o[root] == '|')
    {
        if(v[tree[root][0]] == 0) dfs2(tree[root][1]); //如果左子树结果是0，则标记右子树的值会影响表达式结果
        if(v[tree[root][1]] == 0) dfs2(tree[root][0]); //如果右子树结果是0，则标记左子树的值会影响表达式结果
    }
    if(o[root] == '!') dfs2(tree[root][0]); //子树的值肯定影响结果
}

int main()
{
    getline(cin, str);
    cin >> n;
    for(int i = 1; i <= n; i++) cin >> v[i]; //所有变量初始值

    cnt = n; //节点编号跳过变量编号
    for(int i = 0; i < str.length(); i++)
    {
        if(str[i] == 'x')
        {
            int num = 0;
            int j = i + 1; //读变量x后面的数字
            while(str[j] >= '0' && str[j] <= '9')
            {
                num = num * 10 + str[j] - '0';
                j++;
            }
            stk.push(num); //变量编号入栈
            i = j - 1;
        }
        else if(str[i] == '&' || str[i] == '|')
        {
            int a = stk.top(); stk.pop();
            int b = stk.top(); stk.pop();
            cnt++; //符号节点累加
            stk.push(cnt); //符号节点编号入栈
            tree[cnt].push_back(a); //节点cnt和a之间建立一条边
            tree[cnt].push_back(b); //节点cnt和b之间建立一条边
            o[cnt] = str[i];
        }
        else if(str[i] == '!')
        {
            int a = stk.top(); stk.pop();
            cnt++;
            stk.push(cnt);
            tree[cnt].push_back(a);
            o[cnt] = '!';
        }
    }
    int res = dfs1(stk.top());
    dfs2(stk.top());

    int t;
    cin >> q;
    while(q--)
    {
        cin >> t;
        if(flag[t]) cout << !res << endl;
        else cout << res << endl;
    }

    return 0;
}