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;
}
