触手不及（巴科斯范式求表达式树）

本题为学军神犇 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;
}

__EOF__

本文作者：zjp_shadow
本文链接：https://www.cnblogs.com/zjp-shadow/p/9676609.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！