触手不及（巴科斯范式求表达式树）
本题为学军神犇 cxt 出的神题。
题意
为了避免流露出自己的感情伤害别人, 小 M.M.T. 决定通过一个表达式来传递心意.
给出一个等式.
等式左边是一个 \(int\) 范围内的数, 等式右边是一个合法的 c++ 表达式.
例如:\(233 = 66 ∗ 4 − 31\)
保证等式右边只包含数字 \(x (x ∈ [0, p),p\) 是给定的质数\()\), 加号, 减号, 乘号, 除号, 左右括号.
保证等式中没有任何空格,tab 等不可见字符. 而且保证合法。
但是遗憾的是, 因为一些原因, 该等式不保证成立.
于是, 小 M.M.T. 希望知道, 在模 \(p\) 意义下, 她的表达式的每个数字 \(x\) ,需要变成多少才能使等式成立.
保证原不等式不存在除 \(0\), 你需要保证把数字变成 \(x\) 之后等式仍然不会除 \(0\).
如果无论 \(x\) 取多少都不能使等式成立, 则输出 \(No~Solution\) .
如果无论 \(x\) 取多少都能使等式成立, 则输出 \(-1\) .
\(len,p \le 5 \times 10^6\)
题解
首先很显然的根据给出的中缀表达式来求出二叉表达式树，如何求呢？
其实可以直接递归模拟这个过程。
这就是著名的 BNF（巴科斯范式） ，一种用递归的思想来表述计算机语言符号集的定义规范。
以下函数的名称全部参考自 BNF 。
- 首先最外面一层是由很多 \(+,-\) 号构成的优先级最低的符号，我们最外层处理这个，称为 \(expr\) （表达式）。
- 然后会接下来会分成很多个子表达式，每个最终会代表成一个值，我们把处理这单独一串值称为 \(term\) （相）。
- 每个 $term $ 是可能由 \(0\) 个，甚至多个 \(* ,/\) 连接一些数成的表达式，我们接下来就需要求那些数叫 \(factor\) （因子）
- 然后 \(factor\) 就会分成两种情况，要么为单独一个数（求单个数的为 \(digit\) ），要么就是以括号开头，然后继续是一个完整的表达式 \(expr\) 。
就这样不断递归处理，就可以处理出这颗二叉树了。
说起来似乎很玄学，如果看过代码后，就应该会觉得很好理解了。
整体思路就是，\(expr\) 实际上就是很多 \(term\) 用 \(+,-\) 连接起来的表达式。同理 \(term\) 就是很多 \(factor\) 用 \(*\) 号连接起来的乘积，\(factor\) 要么是个 \(digit\) 要么是个用 \(()\) 包起来的 \(expr\) 。
然后处理出这颗表达式二叉树后，就很好做了，我们令 Dfs(o, val) 表示 \(o\) 这颗子树（表达式）需要满足等式成立需要的改变成 \(val\) 。
递归下去处理，每次用四则运算的逆运算实现就行了。（此处需要预处理每个子树本来代表的值）
注意，叶子就是最后的数字。
然后有几个特殊情况。
- 当前区间运算为 \(*\) ，对于其中一颗子树来说，另一颗子树的值为 \(0\) ，有两种情况。
- \(val \not = 0\) ，怎么改变都不能成立，那么那颗子树内所有点都为 \(No~Solution\) 。
- \(val = 0\) ，怎么改变都可以成立，那么那颗子树内所有点都为 \(-1\) 。
- 当前区间运算为 \(/\) ，有两种特殊情况。
- \(val = 0\) 并且左儿子值 \(\not = 0\) ，那么右儿子整个无解。
- \(val \not = 0\) 并且左儿子值 \(= 0\) ，那么右儿子也是无解。
标程少判了最后一个情况，数据出锅了，差评。
代码
其实还是挺好 抄 写的。
#include <bits/stdc++.h>
#define For(i, l, r) for(register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for(register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
using namespace std;
inline bool chkmin(int &a, int b) {return b < a ? a = b, 1 : 0;}
inline bool chkmax(int &a, int b) {return b > a ? a = b, 1 : 0;}
inline int read() {
int x = 0, fh = 1; char ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') fh = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
return x * fh;
}
void File() {
#ifdef zjp_shadow
freopen ("expression.in", "r", stdin);
freopen ("expression.out", "w", stdout);
#endif
}
const int N = 5e6 + 1e3, Maxn = N << 1;
int Mod, Inv[N]; char str[N];
#define ls(o) ch[o][0]
#define rs(o) ch[o][1]
inline int Add(int a, int b) { return (a += b) >= Mod ? a - Mod : a; }
namespace Expression {
char *Head;
int Size, ch[Maxn][2], val[Maxn], opt[Maxn];
inline void Push_Up(int o) {
if (opt[o] == 0) val[o] = Add(val[ls(o)], val[rs(o)]);
if (opt[o] == 1) val[o] = Add(val[ls(o)], Mod - val[rs(o)]);
if (opt[o] == 2) val[o] = 1ll * val[ls(o)] * val[rs(o)] % Mod;
if (opt[o] == 3) val[o] = 1ll * val[ls(o)] * Inv[val[rs(o)]] % Mod;
}
inline int Digit();
inline int Factor();
inline int Term();
inline int Expr();
inline int Digit() {
int res = 0;
for (; isdigit(*Head); ++ Head) res = (res * 10) + (*Head ^ 48) ;
return res;
}
inline int Factor() {
int Node = 0;
if (*Head == '(')
++ Head, Node = Expr(), ++ Head;
else
val[Node = ++ Size] = Digit();
return Node;
}
inline int Term() {
int Last = Factor(), Node = Last;
while (*Head == '*' || *Head == '/') {
opt[Node = ++ Size] = 2 + (*Head ++ == '/');
ls(Node) = Last; rs(Node) = Factor();
Push_Up(Last = Node);
}
return Node;
}
inline int Expr() {
int Last = Term(), Node = Last;
while (*Head == '+' || *Head == '-') {
opt[Node = ++ Size] = (*Head ++ == '-');
ls(Node) = Last; rs(Node) = Term();
Push_Up(Last = Node);
}
return Node;
}
void Print(int o, const char* ans) {
if (!ls(o) && !rs(o))
return (void) puts(ans);
Print(ls(o), ans); Print(rs(o), ans);
}
void Dfs(int o, int Val) {
if (!ls(o) && !rs(o))
return (void) printf ("%d\n", Val);
if (opt[o] == 0) {
Dfs(ls(o), Add(Val, Mod - val[rs(o)]));
Dfs(rs(o), Add(Val, Mod - val[ls(o)]));
}
if (opt[o] == 1) {
Dfs(ls(o), Add(Val, val[rs(o)]));
Dfs(rs(o), Add(val[ls(o)], Mod - Val));
}
if (opt[o] == 2) {
For (dir, 0, 1)
if (val[ch[o][dir ^ 1]])
Dfs(ch[o][dir], 1ll * Val * Inv[val[ch[o][dir ^ 1]]] % Mod);
else
Print(ch[o][dir], Val ? "No Solution" : "-1");
}
if (opt[o] == 3) {
Dfs(ls(o), 1ll * Val * val[rs(o)] % Mod);
if (Val && val[ls[o]])
Dfs(rs(o), 1ll * val[ls(o)] * Inv[Val] % Mod);
else
Print(rs(o), "No Solution");
}
}
char Sign[4] = {'+', '-', '*', '/'};
void Out(int o) {
if (!o) return ;
if (!ls(o) && !rs(o))
return (void) printf (" %d ", val[o]);
Out(ls(o));
putchar (Sign[opt[o]]);
Out(rs(o));
}
};
void Solve() {
using namespace Expression;
Head = str;
int Base = Digit() % Mod; ++ Head;
int root = Expr();
Dfs(root, Base);
}
int main () {
File();
read(); Mod = read(); scanf ("%s", str);
Inv[0] = Inv[1] = 1;
For (i, 2, Mod - 1) Inv[i] = 1ll * Inv[Mod % i] * (Mod - Mod / i) % Mod;
Solve();
return 0;
}
