<think>题目要求：对于每个查询
字符串s，统计
给定的n个
字符串t中，有多少个满足s
+t是
回文串。
注意：s
+t表示将s接在t的前面，即拼接后
字符串为s[0]s[1]
...s[len
(s
)-1]t[0]t[1]
...t[len
(t
)-1]
设拼接后的
字符串为str，则str是
回文串的条件是：对于任意i，有str[i] = str[len
(str
)-1-i]。
将str分成两部分：s和t。设|s|=L1，|t|=L2，则总长度为L1
+L2。
回文条件可以拆分为：
1
. 对于s的前一部分（长度为min
(L1, L2
)）和t的后一部分（同样长度）必须对称相等。
2
. 然后中间剩余的部分（即较长的那一部分多出来的部分）必须是
回文的。
具体地，考虑两种情况：
(1
) L1 >= L2：此时，s的前L2个字符必须等于t的倒序，并且s剩余的部分（即s[L2:L1]）必须是
回文的。
即：s[0:L2] == reverse
(t
) 且 s[L2:L1]是
回文串。
(2
) L1 < L2：此时，t的后L1个字符必须等于s的倒序，并且t的前L2-L1个字符（即t[0:L2-L1]）必须是
回文的。
即：t[L2-L1:L2] == reverse
(s
) 且 t[0:L2-L1]是
回文串。
因此，对于每个t，我们可能需要存储其长度，以及其反转
字符串（reverse
(t
)）等。
但是，题目中n和q都很大（20万），并且所有
字符串总长度不超过20万，所以我们需要设计高效算法。
思路：使用
字典树（Trie）或
哈希表来存储t的信息，然后对于每个查询s，我们枚举可能的t的长度？但枚举长度显然不可行（因为长度范围可能很大）。
另一种思路：将每个t存储到
哈希表中，并记录每个t出现的次数（因为可能有相同的
字符串）。然后，我们考虑将条件转化为：
条件1（当|s|>=|t|时）：
令L1=|s|, L2=|t|，则要求：
s[0:L2] == reverse
(t
) 且 s[L2:L1]是
回文串。
条件2（当|s|<|t|时）：
t的后|s|个字符（即t[L2-|s|:L2]）等于reverse
(s
)，且t[0:L2-|s|]是
回文串。
因此，对于每个查询s，我们需要统计：
(1
) 对于所有长度L2<=|s|的t，满足：s[0:L2] == reverse
(t
) 且 s[L2:]是
回文串。
(2
) 对于所有长度L2>|s|的t，满足：t的后|s|个字符等于reverse
(s
) 且 t[0:L2-|s|]是
回文串。
但是，我们不能枚举所有t，因为n很大。
因此，我们需要预先处理所有t，将它们按照长度分组，并构建
字典树（或者
哈希表）来存储reverse
(t
)（即t的反转
字符串），同时还要记录每个t的长度。
具体方案：
首先，将所有的t存储，并记录每种t出现的次数（因为可能有重复的
字符串，所以用
map或者数组计数）。
然后，我们构建两棵
字典树（或者使用
哈希表）：
第一棵：存储所有t的反转
字符串（即reverse
(t
)），并同时记录该
字符串的长度（其实在树中路径自然包含了长度，但我们需要知道每个节点对应的是哪些完整的
字符串，以及每个节点对应的长度信息？）
但是，这里我们更关心的是：对于条件1，我们需要快速查询：
给定一个
字符串s，对于每个长度L2（L2<=|s|），我们想知道reverse
(t
)等于s[0:L2]的t的数量，同时还要满足s[L2:]是
回文串。注意，这里s[L2:]是
回文串这个条件与t无关，只与s和L2有关。
所以，对于条件1，我们可以枚举L2（从0到|s|），然后判断s[L2:]是否是
回文串，如果是，则去查询以s[0:L2]为键的t的数量（注意，这里的键是reverse
(t
)的值，即t的反转
字符串等于s[0:L2]）。
然而，枚举L2（即枚举长度）需要O
(|s|
)的时间，而|s|的总长度不超过20万，但是q最大20万，那么总枚举长度可能达到20万*20万？显然不行。
因此，我们需要避免枚举L2。
重新思考：我们能否预先将所有的t按照长度分组，然后对于每个查询s，我们只考虑长度不超过|s|的t，并且要求reverse
(t
)等于s的某个前缀，且该前缀的长度为|t|（即L2），同时s的剩余部分（从L2到末尾）是
回文串。
我们可以构建一棵
字典树，树中插入所有t的反转
字符串（即reverse
(t
)），并在每个
单词的结尾节点记录该
单词出现的次数（注意，同一个t可能出现多次，所以是计数）。
然后，对于每个查询s，我们沿着
字典树匹配，在匹配过程中，当我们匹配到第i个字符（即当前匹配的前缀长度为i）时，我们检查s[i:]是否是
回文串？如果是，那么我们就将当前节点记录的以该节点为结尾的
单词（长度为i）的数量加入到答案中。
注意：这里匹配的长度i就是t的长度（因为reverse
(t
)匹配了s的前i个字符，那么t的长度就是i）。同时，要求s[i:]是
回文串。
这样，我们只需要在
字典树上走一次，并在每个节点检查剩余部分是否
回文。检查
回文串可以用
字符串哈希或者manacher预处理，但是这里我们是在匹配过程中动态检查，而且每个节点都要检查，那么总检查次数可能是O
(总长度
)的，而总长度不超过20万，但是q有20万，那么总检查次数可能会达到20万*20万？因为每个查询s，我们最多检查|s|次（每个节点一次），而|s|的总长度不超过20万，但是q个查询的s总长度可能达到20万（题目说所有
字符串的总长度不超过20万，包括n个t和q个s？注意题目描述：所有
字符串的长度之和不超过20万。所以整个输入的总长度不超过20万，即n个t的总长度加上q个s的总长度不超过20万。因此，q个s的总长度不超过20万，n个t的总长度也不超过20万。所以，我们可以对每个查询s，在
字典树上走|s|步，并且每一步检查剩余部分是否
回文，检查
回文用O
(1
)的
哈希，那么总复杂度是O
(总长度
)，也就是20万。
因此，对于条件1，我们可以这样做：
预处理：构建
字典树，存储所有t的反转
字符串（即reverse
(t
)），并在每个
单词的末尾节点记录该
单词出现的次数（注意，同一个
字符串可能重复出现，所以是计数）。
同时，为了快速检查一个子串是否是
回文串，我们可以预处理每个s的
哈希（但是注意，每个查询s是独立的，我们可以在处理每个查询s时，先计算s的
哈希，然后就可以O
(1
)检查任意子串是否
回文）。但是，由于我们每个查询s只需要检查其从某个位置开始的后缀是否是
回文，我们可以预处理s的正向
哈希和反向
哈希（或者一个
哈希数组）。
然而，我们是在
字典树匹配过程中检查剩余部分（即s[i:]）是否
回文，所以我们需要在匹配前就计算好s的正向和反向
哈希值，这样在匹配过程中就可以O
(1
)判断。
具体步骤：
对于每个查询s：
计算s的正向
哈希数组和反向
哈希数组（或者
两个哈希数组，用于快速计算任意子串的
哈希值，以及其反转的
哈希值，然后比较是否相等）。
然后，将s作为查询串，在
字典树（存储了所有reverse
(t
)）中进行匹配。
在匹配过程中，对于每个位置i（0<=i<=len
(s
)），当我们在
字典树中走到节点p，并且i在[0,len
(s
)]范围内，我们检查s[i:]是否
回文（使用
哈希O
(1
)判断），如果
回文，那么我们就将当前节点p所代表的
单词数量（即长度为i的t的数量）加入答案。注意，这里节点p不一定是
单词结尾节点，所以我们需要在
字典树节点中存储一个计数，表示以该节点为结尾的
单词的数量。
注意：匹配过程中，我们每走一步（即匹配一个字符），就检查当前剩余部分（从当前位置到末尾）是否
回文。因此，在匹配到第i个字符时（即匹配了前i个字符），我们检查s[i:]是否
回文。
但是，这里有一个问题：
字典树中存储的是reverse
(t
)，而我们在匹配s的前缀，所以匹配的前i个字符就是reverse
(t
)（如果t的长度为i）。所以，当t的长度为i时，我们要求s的前i个字符等于reverse
(t
)，即t等于reverse
(s[0:i]
)。同时，要求s[i:]是
回文串。
这正是条件1。
接下来，我们还要考虑条件2：对于长度L2>|s|的t，满足：t的后|s|个字符等于reverse
(s
) 且 t[0:L2-|s|]是
回文串。
如何处理条件2？
条件2要求：t[L2-|s|:L2] = reverse
(s
) 且 t[0:L2-|s|]是
回文串。
我们可以将t拆成两部分：前缀A = t[0:L2-|s|] 和后缀B = t[L2-|s|:L2] = reverse
(s
)。
所以，t = A
+ reverse
(s
)，其中A是一个
回文串。
那么，对于每个t，我们可以将其后缀reverse
(s
)去掉，剩下的部分必须是
回文串。但是，查询s是变化的，所以我们需要对每个查询s，要求t的后缀是reverse
(s
)，而前缀是任意
回文串。
因此，我们可以考虑：预先将所有的t按照后缀分组？即对于每个t，我们将其所有后缀（即从某个位置开始到末尾的子串）作为键？但是这样空间太大。
另一种思路：构建另一棵
字典树，这次存储的是t本身（而不是反转），并且我们按照t的后缀来构建（即后缀树？）或者使用AC自动机的思想？但是题目总长度只有20万，我们可以考虑将t反转后插入一棵
字典树，然后利用这棵
字典树来处理条件2？
重新整理条件2：t = A
+ B，其中B=reverse
(s
)，且A是
回文串。所以，t的后缀B=reverse
(s
)是固定的，而A是
回文串。
那么，对于每个查询s，我们要求t以reverse
(s
)为后缀，且t除去该后缀后的前缀是
回文串。
因此，我们可以将所有的t反转，然后插入
字典树（这样原来t的后缀就变成了反转后的前缀），然后在这棵
字典树中，我们查询s的反转（即reverse
(s
)）作为键，在匹配过程中，当匹配完整个reverse
(s
)后，我们还需要知道从该节点开始，剩下的部分（即t除去后缀reverse
(s
)后的部分，注意这里t已经被反转，所以剩下的部分实际上是原t的前缀A的反转）是一个
回文串？但是这里注意：原t的前缀A是
回文串，那么A的反转等于A吗？不一定，因为
回文串反转后等于自身，所以A反转后还是A。因此，在反转t的
字典树中，匹配完reverse
(s
)后，剩下的部分（即从该节点往下的路径）应该是一个
回文串。
但是，我们不可能在
字典树中存储每个节点往下的所有路径是否是
回文串，而且每个节点往下可能有多个分支。
因此，我们换一种方式：预先将每个t拆分成两部分：设t的长度为L2，对于每个可能的后缀长度k（k从1到L2），我们将t[0:L2-k]（即前缀A）取出来，然后要求A是
回文串，然后以t[L2-k:L2]（即后缀B）作为键存储。这样，对于查询s，我们只需要查询键为reverse
(s
)的项，并且要求这些项的前缀A是
回文串。但是，k就是|s|，所以对于每个t，我们只考虑k=|s|的情况？但是s的长度是变化的，我们不可能为每个可能的k都存储。
所以，我们可以将所有的t按照后缀的长度（即k）进行分组？但是k是变化的，而且查询s的长度也是变化的。
更好的做法：将每个t的所有后缀信息存储在一个
哈希表中。具体地，对于每个t，我们枚举其所有后缀（即从每个位置i开始到末尾），然后以该后缀为键，存储该后缀对应的前缀（即t[0:i]）是否为
回文串？但是，枚举所有后缀，总复杂度是O
(len
(t
)^2
)，总长度20万，但单个
字符串可能很长，最坏情况所有
字符串都是同一个字符，那么一个
字符串长度20万，枚举后缀就是O
(n^2
)，不可接受。
因此，我们需要一个更高效的方法。
参考条件1的处理，条件2也可以利用
字典树，但是这次我们构建的是反转t的
字典树（即存储reverse
(t
)的
字典树，注意和条件1的树是同一棵？）不行，条件1的树已经存储了reverse
(t
)，但条件2需要的是t的后缀等于reverse
(s
)，即reverse
(t
)的前缀等于s？不对。
条件2：t的后缀B=reverse
(s
)，即t的最后|s|个字符等于reverse
(s
)。那么，reverse
(t
)的前|s|个字符等于s（因为t的后缀B反转后变成reverse
(B
)=s，而B在t的尾部，反转后位于reverse
(t
)的头部）。同时，t的前缀A是
回文串，而A在t中位于B之前，所以A在reverse
(t
)中位于B之后，即reverse
(t
)的后面部分（从|s|到末尾）是A的反转，而A是
回文串，所以A反转后还是A。因此，条件2等价于：reverse
(t
)的前|s|个字符等于s，且reverse
(t
)的剩余部分（从|s|到末尾）是
回文串。
注意：条件1：当|s|>=|t|时，reverse
(t
)等于s的前|t|个字符，且s的剩余部分是
回文串。
条件2：当|s|<|t|时，reverse
(t
)的前|s|个字符等于s，且reverse
(t
)的剩余部分是
回文串。
所以，两种情况可以统一为：对于每个t，设其反转
字符串为rt=reverse
(t
)。那么，对于查询s，满足：
如果|s|>=|t|，则要求rt等于s的前|t|个字符，且s[|t|:]是
回文串。
如果|s|<|t|，则要求s等于rt的前|s|个字符，且rt[|s|:]是
回文串。
因此，我们可以将所有的rt（即reverse
(t
)）插入一棵
字典树，并在每个节点记录：以该节点结尾的
字符串（即rt）的长度（因为rt的长度就是原t的长度）？但是，我们需要在匹配过程中，根据当前匹配的长度（设为i）和t的长度（设为L）来区分两种情况：
情况1：当L<=|s|时，此时匹配的长度为L（即整个rt都匹配上了），我们要求s[L:]是
回文串。
情况2：当L>|s|时，此时匹配的长度为|s|（即只匹配了rt的前|s|个字符），我们要求rt[|s|:]是
回文串。
但是，在
字典树匹配过程中，我们只能匹配到s的前缀（因为s的长度是|s|，所以最多匹配|s|个字符）。因此，对于情况1，如果t的长度L<=|s|，那么我们在匹配到第L个字符时（即匹配了整个rt），此时我们检查s[L:]是否
回文；对于情况2，如果t的长度L>|s|，那么我们在匹配完整个s（即|s|个字符）后，需要检查rt[|s|:]是否
回文，但是此时我们只匹配了rt的前|s|个字符，还没有匹配整个rt，所以我们在
字典树中并不知道rt[|s|:]是什么（因为
字典树只存储了rt，但匹配到当前节点，我们不知道剩余部分）。
因此，我们需要在
字典树中存储每个t的完整信息？这不可能。
我们可以这样：在
字典树中，对于每个节点，我们存储经过该节点的所有t的完整信息（即rt的完整
字符串）？这样空间太大。
所以，我们需要将条件2单独处理。
重新考虑：我们可以将条件2转化为：在
字典树中，当匹配到s的末尾时（即匹配了|s|个字符），我们检查所有以当前节点为前缀的rt（即reverse
(t
)）中，那些rt的长度大于|s|，并且rt[|s|:]是
回文串的t的数量。
因此，我们可以在
字典树每个节点上挂一个
列表，存储所有经过该节点的rt的剩余部分（即从该节点开始的后缀）？但是，一个节点可能有多个
字符串经过，而且剩余部分各不相同。
但是，注意：在
字典树中，从当前节点到叶子节点的路径就是rt的剩余部分。但是，同一个节点下可能有多条分支，我们需要知道每条路径（即每个
字符串）的剩余部分是否是
回文串。而且，我们需要在插入时就将每个
字符串的剩余部分（从该节点开始）是否是
回文串存储？但是，剩余部分在插入时是确定的，所以我们可以预先计算每个rt的所有后缀是否是
回文串？这样，对于每个rt，我们可以将其拆分成前缀（已经匹配）和后缀（剩余部分），然后存储在该节点：以该节点为键，存储（长度，后缀是否为
回文）的信息？但是，每个节点需要存储很多信息。
因此，我们可以这样做：在
字典树每个节点上维护一个映射（或者一个数组），记录以该节点为前缀的所有rt
字符串的剩余部分（即从该节点开始的后缀）是否是
回文串。但是，剩余部分是否
回文需要整个后缀，而我们在插入时就可以计算，所以可以在插入时，对于每个rt，在它经过的每个节点，记录：如果从当前节点位置开始的后缀是
回文串，那么就在该节点记录这个rt（或者计数）？但是，同一个
字符串在多个节点都记录，空间太大。
另一种思路：对于条件2，我们构建另一棵
字典树，存储所有的t（注意，不是反转），然后按照类似条件1的方式处理？但是条件1我们处理的是s的前缀匹配reverse
(t
)，而条件2需要的是t的后缀匹配reverse
(s
)。
实际上，条件2可以转化为：将s反转，然后看t是否以reverse
(s
)为后缀，并且t除去该后缀后的前缀是
回文串。所以，我们可以将所有的t插入一棵
字典树（存储原
字符串），然后对每个查询，将s反转得到rs，然后在该
字典树中匹配rs（注意，后缀匹配可以先将t反转然后变成前缀匹配？但是这里我们存储的是原t，所以匹配后缀需要从后往前匹配，
字典树是前缀匹配，所以不行）。
因此，我们可以构建一棵后缀树？或者将所有的t反转后存储，然后匹配反转后的s（即原s）？这样就和条件1的树一样了。但是，条件2要求的是t的后缀等于reverse
(s
)，即反转t（得到rt）的前缀等于s。所以，我们可以在同一棵存储reverse
(t
)的
字典树中处理条件2：因为条件2要求rt的前|s|个字符等于s，所以匹配到s的末尾（即匹配了|s|个字符），然后要求rt的剩余部分是
回文串。
因此，我们在
字典树中插入所有的rt（即reverse
(t
)），然后在每个节点，我们存储
两个信息：
cnt1: 表示以该节点为结尾的
字符串（即完整的rt）的数量（用于条件1：匹配了整个rt，即|s|>=|t|的情况）。
cnt2: 一个映射（或者一个数组），记录从该节点开始的后缀（即rt的剩余部分）是
回文串的
字符串的数量。但是，由于一个节点下可能有多个
字符串，而且剩余部分
不同，我们需要按长度？不，我们不需要按长度，因为条件2中，匹配的长度就是|s|，所以剩余部分就是rt[|s|:]，而rt的长度就是原t的长度L，所以剩余部分长度是L-|s|。我们在插入时，对于每个
字符串rt，在它经过的每个节点，我们记录：如果从这个节点开始的后缀是
回文串，那么就将该
字符串的计数加到该节点的一个计数器上（注意，同一个
字符串在多个节点都会出现，所以每个节点记录的是：以该节点为起点的后缀是
回文串的
字符串的数量）。
但是，在插入时，对于每个
字符串rt，我们沿着
字典树插入，对于每个节点（对应rt的一个前缀），我们判断剩余部分（即当前节点到末尾的部分）是否是
回文串，如果是，则在该节点的cnt2上加上该
字符串的计数（注意，每个t是独立的，计数为1，但可能有重复的t，所以用总的出现次数）。
然后，对于每个查询s：
我们在
字典树中匹配s，在匹配过程中：
对于每个位置i（0<=i<=len
(s
)），如果i小于等于len
(s
)且匹配成功，则：
如果i等于某个rt的长度（即当前节点是某个rt的结尾），那么说明匹配了一个完整的rt（即条件1），此时我们检查s[i:]是否
回文，如果是，则答案加上该节点的cnt1（即这个完整rt的计数）。
注意：这里我们可以在插入时，在结尾节点存储cnt1（即该
字符串出现的次数），然后在匹配过程中，每到一个节点，如果该节点cnt1>0，并且当前匹配位置i<=len
(s
)且s[i:]是
回文，则加上cnt1。但是，这里有一个问题：同一个t，其rt在
字典树中是一个完整的
字符串，所以只有走到结尾节点时，才代表匹配了整个rt。
另外，对于条件2，当我们匹配完整个s（即匹配了|s|个字符，此时可能还没匹配完当前路径，因为rt的长度可能大于|s|），那么我们在当前节点，将cnt2的值加入答案。因为cnt2表示：从当前节点开始的后缀是
回文串的
字符串的数量，这些
字符串就是满足条件2的t（即rt的前|s|个字符等于s，且剩余部分是
回文串）。
因此，在匹配s结束时（即匹配了|s|个字符），我们到达节点p，那么答案加上p->cnt2。
但是，这里有一个问题：在条件1中，我们是在匹配过程中，每匹配到一个结尾节点，就检查剩余部分是否
回文，然后加入。而在条件2中，我们只在匹配完整个s后，在结束节点p加上cnt2。注意，条件1和条件2是互斥的（因为条件1要求|s|>=|t|，条件2要求|s|<|t|），所以不会重复计数。
因此，算法如下：
预处理：
构建
字典树，节点结构：
struct Node {
Node* child[26];
int cnt1; // 以该节点为结尾的
字符串（完整的rt）的数量（即条件1中匹配整个rt）
int cnt2; // 从该节点开始的后缀是
回文串的
字符串的数量（用于条件2）
};
插入一个
字符串rt（即reverse
(t
)）时：
从根节点开始，对于rt的每个字符c（顺序遍历）：
如果当前节点没有c的孩子，创建。
然后，在沿着路径走的过程中，对于每个节点，在当前位置，判断剩余部分（即rt中从当前位置
+1到末尾的子串）是否是
回文串？如果是，则在该节点的cnt2上加上该
字符串的计数（注意，这里每个t的计数为1，但可能有重复，所以用总出现次数？但是，我们插入的是每个t，每个t出现多次，我们插入多次？还是计数？）
但是，注意：一个
字符串rt在插入过程中，会经过多个节点，每个节点对应一个前缀。对于节点p（对应rt的前缀[0:i]），剩余部分就是rt[i:len
(rt
)]。我们需要判断rt[i:]是否是
回文串。如果是，那么在该节点的cnt2上加1（表示有一个
字符串，从该节点开始的后缀是
回文串）。
最后，在结尾节点，将cnt1加1（表示一个完整的rt
字符串）。
但是，这里有一个问题：同一个
字符串rt，在插入过程中，每个节点都要判断剩余部分是否
回文，而且判断的剩余部分
不同。我们可以预先计算rt的所有后缀是否
回文？在插入过程中，我们不知道剩余部分，所以可以在插入前先计算好rt的所有后缀是否
回文，然后插入时，在每一个节点，根据当前位置i，判断后缀rt[i:]是否
回文。
具体：在插入
字符串rt前，我们先计算rt的所有后缀是否
回文，即计算一个数组isPal[i]表示rt[i:]是否是
回文串（i从0开始）。然后，在插入到第i个字符时（即已经匹配了i个字符，当前节点对应rt[0:i]），将isPal[i]的值判断，如果为真，则在该节点的cnt2上加上该
字符串的计数（注意，这里每个
字符串只计数一次，但插入时每个t独立插入，所以如果同一个t出现多次，我们插入多次，每次计数1）。
但是，同一个t出现多次，那么rt相同，所以每个节点上cnt2会加多次（每次插入都加）。所以，我们在插入一个t时，计数为c（即该t出现了c次），那么我们在每个节点上cnt2加c（如果该节点的剩余部分是
回文串）。
因此，我们需要知道每个t出现的次数。所以，我们先用一个
map统计每个t出现的次数，然后对于每个
不同的rt（即
不同的t），我们插入一次，并在
字典树中加上次数。
但是，注意：
不同的t可能有相同的rt（即t1和t2
不同，但reverse
(t1
)=reverse
(t2
)），那么它们对应的rt相同，所以插入时在同一个路径上，所以我们可以合并：即对于相同的rt，我们只插入一次，计数为c（出现次数）。
所以，步骤：
map<string, int> count
Map; // 统计每个t出现的次数
然后，对于每个
不同的t（即
不同的
字符串），计算其rt=reverse
(t
)，然后计算rt的所有后缀是否
回文（即计算数组isPal，长度len
(rt
)+1，其中isPal[i]表示rt[i:]是
回文串，i从0到len
(rt
)）。
然后，将rt插入
字典树，插入时，在路径上的每个节点i（即已经匹配了i个字符，当前节点对应rt[0:i]），如果isPal[i]为真，则当前节点的cnt2加上count
Map[t]（即该t出现的次数）。
最后，在结尾节点，cnt1加上count
Map[t]。
这样，
字典树就构建好了。
查询时，对于每个查询s：
初始化答案ans=0。
从根节点开始，匹配s的每个字符：
如果遇到空节点，则停止，然后直接跳到结束（但此时可能已经匹配了一部分，所以条件1可能已经统计了一部分？）
在匹配过程中，设当前匹配到第i个字符（0<=i<len
(s
)），当前节点为p：
如果p->cnt1>0，说明存在一个rt（即一个t）长度等于i（因为匹配了i个字符，并且该节点是结尾节点，所以rt的长度为i），那么检查s[i:]（即剩余部分）是否
回文？如果是，则ans
+= p->cnt1。
然后，继续匹配下一个字符。
当匹配完整个s（即匹配了i=len
(s
)个字符），此时当前节点为p，那么：
ans
+= p->cnt2; // 这里cnt2表示所有以s为前缀的rt，且剩余部分是
回文串的
字符串的数量（即条件2）
但是，注意：在匹配过程中，我们只检查了条件1中t的长度等于i（即匹配了整个rt）的情况，但是条件1中t的长度i<=|s|，所以我们在匹配过程中检查了所有i<=|s|的结尾节点（即完整匹配了某个rt）。
而条件2在匹配结束节点p上加上cnt2，即所有满足条件2的t的数量。
因此，输出ans。
但是，这里有一个问题：在匹配过程中，当我们匹配到第i个字符时，我们只检查了当前节点p的cnt1（即完整匹配且长度为i的rt），但是，在匹配路径上，可能之前经过的节点也有cnt1>0，但我们在经过时已经检查了。因为我们是边匹配边检查，每到一个节点，如果该节点是某个rt的结尾（即cnt1>0），就检查剩余部分是否
回文。
另外，在匹配过程中，我们可能提前结束（比如匹配到某个字符没有孩子），那么就不会再往下匹配，所以不会漏掉条件1的统计（因为条件1要求匹配整个rt，如果匹配失败，那么rt不可能被完整匹配）。而条件2要求匹配整个s（即匹配|s|个字符），所以如果匹配s的过程中失败，那么条件2也不会满足（因为要求rt的前|s|个字符等于s，如果匹配失败，说明rt的前|s|个字符不等于s），所以此时ans只包含条件1中匹配的部分。
因此，查询过程：
p = root
ans = 0
for i in range
(len
(s
)):
c = s[i]
if p->child[c] is null: break
p = p->child[c]
// 检查当前节点p：如果p->cnt1>0，说明有一个rt的长度为i
+1（因为已经匹配了i
+1个字符）? 注意：我们匹配了i
+1个字符，所以当前节点p对应第i
+1个字符。
if p->cnt1 > 0 and is_palindrome
(s, i
+1, len
(s
)-1
):
ans
+= p->cnt1
// 如果匹配完了整个s（即没有break，且i=len
(s
)），那么当前节点p就是匹配结束节点
if i==len
(s
): // 实际上，循环结束后，i的值为len
(s
)-1，然后我们还要判断最后一步是否匹配成功？实际上，循环内部已经匹配了所有字符，所以最后p指向匹配s结束的节点。
ans
+= p->cnt2
// 但是，在匹配过程中，我们只检查了条件1中长度为i
+1（即匹配了i
+1个字符）的rt，那么长度为0的rt（即空
字符串）呢？题目中
字符串非空，所以不会有长度为0的。
但是，这里有一个细节：在匹配第0个字符时（即第一个字符），我们匹配后到达节点p1，然后检查p1的cnt1，如果p1的cnt1>0，说明有一个rt长度为1，然后检查s[1:]是否
回文。所以，我们需要在循环中每匹配一个字符就检查。
另外，在判断子串s[i:]是否
回文时，我们可以用
字符串哈希（预处理s的正向
哈希和反向
哈希）来O
(1
)判断。所以，在查询前，我们计算s的正向
哈希和反向
哈希。
但是，注意：在条件1中，我们检查的是s[i:]（i从0到len
(s
)）是否
回文，其中i是当前匹配的字符数（即已经匹配了i个字符，当前节点对应第i个字符，所以剩余部分从下标i开始）。所以，在循环中，我们匹配了i
+1个字符（因为i从0开始，匹配第一个字符后i=0，此时匹配了1个字符，剩余部分从下标1开始），所以对应的剩余子串是s[i
+1:]。但是，在代码中，我们循环变量i是下标，从0到len
(s
)-1，匹配第i个字符后，剩余部分就是s[i
+1:]。
因此，在循环中，当我们匹配了第i个字符（0-indexed，即当前下标为i的字符）后，我们位于节点p（该节点对应rt的前i
+1个字符），那么：
如果p->cnt1>0，说明有一个rt的长度为i
+1，所以剩余部分应该是s[i
+1:len
(s
)]，我们检查这个子串是否
回文。
所以，代码中：
for i in range
(len
(s
)):
c = s[i] - 'a'
if p->child[c] is null: break
p = p->child[c]
if p->cnt1 > 0 and i
+1 <= len
(s
)-1:
if is_palindrome
(s, i
+1, len
(s
)-1
): # 检查s[i
+1:] 注意：子串从i
+1到末尾
ans
+= p->cnt1
# 注意：如果i
+1==len
(s
)，那么剩余部分为空，空串是
回文串，所以也要算。
if p->cnt1 > 0 and i
+1 == len
(s
):
ans
+= p->cnt1 # 因为剩余部分为空，
回文。
// 或者合并：
for i in range
(len
(s
)):
c = s[i] - 'a'
if p->child[c] is null: break
p = p->child[c]
if p->cnt1 > 0:
if i
+1==len
(s
) or is_palindrome
(s, i
+1, len
(s
)-1
): # 注意：如果i
+1==len
(s
)，剩余部分为空，我们认为是
回文。
ans
+= p->cnt1
// 然后，匹配完整个s后：
if i==len
(s
)-1: # 注意循环结束，i=len
(s
)-1，所以匹配了所有字符
ans
+= p->cnt2
但是，这里有一个边界：当匹配完整个s，且当前节点p的cnt1>0，那么我们在循环中已经加了一次cnt1（因为匹配到最后一个字符时，在循环内判断了cnt1>0，并且剩余部分为空，所以加了一次），然后最后又加了cnt2。但是，这个t满足条件1（因为|s|>=|t|，且|t|=len
(s
)，因为匹配了len
(s
)个字符，所以|t|=len
(s
)）？不对，rt的长度为len
(s
)，所以|t|=len
(s
)，而|s|>=|t|成立（相等），所以它满足条件1。而条件2要求|s|<|t|，所以这个t不会被条件2统计。因此，我们在最后加cnt2时，不会重复计数。
但是，在循环中，我们匹配到最后一个字符时，已经统计了条件1（即cnt1），而最后又加上了cnt2，那么同一个t会被统计两次吗？
注意：在
字典树中，一个
字符串rt（长度为L）在结尾节点（即第L个节点）的cnt1被设置为该
字符串出现的次数。而cnt2是我们在插入过程中，在路径上的每个节点（包括结尾节点）都判断了剩余部分是否
回文，如果
回文就加cnt2。所以，在结尾节点，cnt2可能也包含这个
字符串吗？
回顾插入过程：在插入rt时，在结尾节点（对应整个rt），剩余部分为空，空串是
回文串，所以我们在结尾节点的cnt2上也会加上这个
字符串的计数。因此，在查询时，如果s的长度等于rt的长度（即匹配了整个rt），那么我们在循环内会加一次cnt1（因为结尾节点cnt1>0），然后在循环结束后，在结尾节点再加一次cnt2（因为p->cnt2包含了这个
字符串）。这样，同一个t就被统计了两次。
所以，我们需要避免重复。如何避免？
实际上，条件1和条件2是互斥的：条件1要求|s|>=|t|，条件2要求|s|<|t|。所以，当|s|=|t|时，只满足条件1，不满足条件2。因此，在条件2的cnt2中，不应该包含那些长度等于|s|的
字符串？但是，我们在插入时，对于每个节点，只要剩余部分是
回文串，我们就加到cnt2，而结尾节点的剩余部分为空（
回文），所以也被加到了cnt2。
所以，在条件2中，我们只考虑长度大于|s|的
字符串。因此，在插入时，对于结尾节点，我们虽然加了cnt2（因为剩余部分为空，
回文），但是，在查询时，当我们匹配整个s（即|s|个字符）时，在结尾节点，cnt2包含了所有经过该节点的
字符串（包括长度等于|s|的，也包括大于|s|的）中，剩余部分（从该节点开始）是
回文串的
字符串的数量。但是，条件2要求长度大于|s|，所以长度等于|s|的不应该算。
因此，我们需要将cnt2按长度区分？或者，我们在插入时，对于每个
字符串rt，在结尾节点不加cnt2？因为结尾节点的剩余部分为空，但条件2要求长度大于|s|，所以剩余部分为空的情况只发生在长度等于|s|时，而条件2要求大于，所以不应该加。
但是，我们在插入时，在结尾节点（即第L个字符的节点）的剩余部分为空，所以我们在该节点加了cnt2（加1）。但是，这个
字符串rt的长度为L，那么当查询s的长度为L时，我们在该节点会加上这个
字符串的cnt2（因为匹配了L个字符，然后加上p->cnt2），而实际上这个
字符串应该只被条件1统计。
所以，为了避免重复，我们在插入时，不在结尾节点加cnt2？因为结尾节点的剩余部分为空，而空串是
回文，但条件2要求的是长度大于当前匹配前缀（即|s|）的
字符串，而结尾节点的
字符串长度等于|s|（在匹配整个s时），所以不应该算。因此，我们在插入时，对于每个rt，在插入到结尾节点时（即最后一个字符的节点），我们不加cnt2？因为剩余部分为空，但是条件2要求的是大于，所以这个
字符串在条件2中不会被使用（因为条件2要求长度大于|s|，所以当|s|>=|t|时，条件2不成立）。所以，实际上，对于结尾节点，我们加不加cnt2，在条件2中都不会被统计？因为条件2要求长度大于|s|，而结尾节点对应的
字符串长度等于当前匹配的前缀长度（即|s|）？不对，在查询时，当匹配s结束，如果s的长度等于rt的长度，那么我们在结尾节点，此时剩余部分为空，但是条件2要求的是长度大于|s|的
字符串，所以这个
字符串不会被条件2统计？因为条件2要求长度大于|s|，而该
字符串长度等于|s|，所以不符合。
但是，我们在插入时，在结尾节点（即第L个节点）加cnt2，表示这个
字符串的剩余部分（空串）是
回文串。然后，在查询时，如果s的长度等于L，那么我们在结尾节点加上cnt2，就会包含这个
字符串。但是，这个
字符串应该只被条件1统计（因为|s|=L>=L，满足条件1），而条件2不应该统计。所以，我们重复统计了。
因此，我们需要修改：在插入时，对于每个rt，在结尾节点不加cnt2。因为，结尾节点的剩余部分为空，而条件2要求的是大于匹配前缀长度的
字符串，所以这个
字符串在条件2中永远不会被使用（因为条件2要求长度大于匹配的前缀长度，而结尾节点对应的
字符串长度等于匹配的前缀长度）。所以，我们在插入时，只考虑非结尾节点？不对，非结尾节点也可能对应剩余部分为空吗？不可能，因为非结尾节点的剩余部分至少还有一个字符（因为还没到结尾）。
所以，我们可以在插入时，对于每个rt，在路径上的每个节点（除了结尾节点）判断剩余部分是否
回文，然后加cnt2。而在结尾节点，我们只加cnt1，不加cnt2（因为剩余部分为空，而条件2要求长度大于匹配长度，所以这个
字符串在条件2中不会被使用，所以不用加）。
但是，条件2中，如果匹配长度|s|小于rt的长度，那么剩余部分非空，所以我们在插入时，在非结尾节点（即匹配长度小于rt的长度）已经加了cnt2（如果剩余部分
回文）。所以，结尾节点我们不加cnt2。
因此，插入过程修改：在插入rt时，对于每个位置i（0<=i<len
(rt
)），在节点p（对应rt[0:i]）时，判断剩余部分rt[i:]是否
回文，如果是，则cnt2
+= count。注意，这里i<len
(rt
)，所以剩余部分非空？不一定，当i=len
(rt
)时，剩余部分为空，但我们不处理（因为循环i只到len
(rt
)-1）。所以，在结尾节点（即i=len
(rt
)）我们只加cnt1，不加cnt2。
具体：在插入循环中，i从0到len
(rt
)-1，在进入下一个节点前，判断剩余部分rt[i:]是否
回文？注意，这里rt[i:]包括当前字符rt[i]和后面的字符。所以，在节点p（对应rt[0:i]）时，我们判断rt[i:]是否
回文，如果是，则p->cnt2
+= count。然后，再进入下一个节点（对应rt[0:i
+1]）。
但是，在节点p（对应rt[0:i]）时，剩余部分为rt[i:]，而当我们匹配到该节点时，匹配长度是i（即已经匹配了i个字符），那么条件2要求剩余部分（rt[i:]）是
回文串。所以，在插入时，我们在节点p（对应rt[0:i]）判断rt[i:]是否
回文，如果是，则加上。
然后，在结尾节点（即rt[0:len
(rt
)]），我们只加cnt1。
这样，在查询时，匹配到节点p（对应匹配长度i），如果p->cnt1>0，则加上（条件1），然后匹配完整个s（匹配长度|s|）后，在节点p加上p->cnt2（条件2），此时cnt2中不包含长度等于|s|的
字符串（因为插入时，在结尾节点没有加cnt2），所以不会重复。
但是，在插入时，对于结尾节点（即整个rt），我们并没有判断剩余部分（空串）是否
回文并加到cnt2，所以不会在条件2中统计。而条件1中，我们通过cnt1统计了。
因此，插入代码：
void insert
(string rt, int count
) {
Node* p = root;
// 预处理rt的后缀
回文数组：pal[i]表示rt[i:]是
回文串
vector<bool> pal = precomputePal
(rt
); // pal[i] for i in [0, len
(rt
)]
for
(int i=0; i<rt
.size
(); i
++) {
int c = rt[i] - 'a';
if
(p->child[c] == nullptr
) {
p->child[c] = new Node
();
}
p = p->child[c];
// 判断剩余部分rt[i:]是否
回文？用pal[i]判断
if
(pal[i]
) { // 注意：这里pal[i]表示rt[i:]是
回文串
p->cnt2
+= count; // 注意：此时p已经指向新节点，即对应rt[0
..i]
}
}
p->cnt1
+= count;
}
注意：在循环中，当i=0时，剩余部分就是整个rt，如果整个rt是
回文，那么节点p（对应第一个字符）的cnt2会加上count。然后，当匹配到整个rt时，结尾节点的cnt1加上count。
在查询时，我们匹配s，在匹配过程中，对于每个节点（对应匹配长度i，即已经匹配了i个字符，i从1到|s|），如果该节点cnt1>0，且s的剩余部分（从i到末尾）是
回文，则加上cnt1。然后，匹配完整个s，加上当前节点的cnt2。
这样，对于同一个t，如果rt是
回文串，那么：
条件1：当s为空
字符串时，匹配长度0，但题目非空，所以不考虑。当s的长度等于rt的长度时，匹配整个rt，在结尾节点，我们会检查s的剩余部分（空）是
回文，所以加上cnt1。
条件2：当s的长度小于rt的长度时，匹配到s的末尾，在节点p（对应匹配长度|s|）加上cnt2，而cnt2中在插入时已经加了这个
字符串（因为rt[|s|:]是
回文串？不一定，如果整个rt是
回文，那么rt[|s|:]不一定是
回文）。所以，这里我们只关心插入时在节点p（对应rt[0:|s|]）时，判断的rt[|s|:]是
回文串，所以加了cnt2。
因此，不会重复。
但是，在插入时，我们在每个节点p（对应rt[0:i]）判断的是rt[i:]是否
回文，而在查询条件2时，匹配长度i=|s|，我们加上p->cnt2，而p->cnt2包含了所有满足rt[i:]是
回文串的
字符串（即t）的数量。
所以，正确。
最后，我们还需要快速判断s的任意子串是否
回文，所以对于每个查询s，我们预处理其
哈希值（正向和反向），然后O
(1
)判断子串是否
回文。
注意：总
字符串长度（n个t和q个s）不超过20万，所以我们可以对每个查询s，预处理其
哈希，复杂度O
(|s|
)，总复杂度O
(总长度
)=20万。
因此，整个算法：
预处理：用一个
map统计每个t出现的次数。
构建
字典树：对于每个
不同的t，计算rt=reverse
(t
)，然后计算rt的所有后缀是否
回文（使用
哈希预处理，O
(len
(rt
))），然后插入
字典树（次数为count
Map[t]）。
然后，处理每个查询s：
预处理s的正向
哈希和反向
哈希（用于快速判断子串
回文）。
初始化ans=0，p=root。
遍历s的每个字符：
如果当前节点p没有当前字符的孩子，则break。
否则，p移动到孩子节点。
如果p->cnt1>0，则检查s的剩余部分（从当前下标
+1到末尾）是否
回文（注意：当前下标为i，匹配了i
+1个字符，所以剩余部分从i
+1开始）。如果
回文，则ans
+=p->cnt1。
如果成功匹配完整个s，则ans
+=p->cnt2。
输出ans。
注意：在匹配过程中，如果提前break，则不会继续匹配，所以不会执行最后一步的cnt2。
另外，在判断s的剩余部分是否
回文时，如果剩余部分为空（即i
+1==len
(s
)），则认为是
回文。
但是，注意：在循环中，当匹配到第i个字符（0-indexed）后，我们位于节点p，此时匹配长度是i
+1，所以剩余部分为s[i
+1:]。如果i
+1>len
(s
)-1，即剩余部分为空，则直接判断为
回文。
所以，代码中：
if
(p->cnt1 > 0
) {
if
(i
+1 == s
.size
() || isPal
(s, i
+1, s
.size
()-1
)) {
// isPal
(s,l,r
)判断s[l
..r]是否
回文
ans
+= p->cnt1;
}
}
其中，isPal
(s,l,r
)使用
哈希O
(1
)判断。
但是，注意：在匹配过程中，有可能在匹配到某个节点时，该节点不是结尾节点（即cnt1=0），所以不需要判断。
最后，注意内存：
字典树节点数量最多为所有rt的长度和，而总长度不超过20万，所以节点数最多20万。
另外，
哈希方法：使用双
哈希避免冲突。
实现细节：
哈希方法：取
两个模数，base=131, 13331等。
预计算s的
哈希数组：
h[i] =
(h[i-1]*base
+ s[i]
) % mod
hr[i] =
(hr[i
+1]*base
+ s[i]
) % mod // 反向
然后，子串s[l
..r]的
哈希值：
hash =
(h[r] - h[l-1]*pw[r-l
+1]
) % mod // 注意l=0的情况
反向子串的
哈希值（即s[l
..r]反转后的
哈希值，等于原串从r到l）：
rhash =
(hr[l] - hr[r
+1]*pw[r-l
+1]
) % mod
然后比较hash和rhash是否相等。
由于总长度20万，我们可以预计算pw数组（幂次）到200000。
但是，每个查询s的长度
不同，我们需要为每个s计算
哈希数组。而总长度20万，所以可以。
注意：在插入时，对于每个rt，我们也要计算其所有后缀是否
回文，这里也需要
哈希。所以，我们写一个函数判断一个
字符串的任意子串是否
回文？但是，在插入时，我们要判断rt[i:]是否
回文，所以我们可以用同样的
哈希方法，在O
(1
)时间内判断。
因此，在插入前，对于每个rt，我们预处理其正向和反向
哈希，然后就可以O
(1
)判断任意后缀是否
回文。
所以，整个代码结构：
// 定义
哈希结构（双
哈希）
typedef pair<long long, long long> HashPair;
const long long mod1 = 1e9
+7, mod2 = 1e9
+9;
const long long base = 131;
struct StringHash {
vector<long long> h1, h2, hr1, hr2, pw1, pw2;
string s;
int n;
void init
(string str
) {
s = str;
n = s
.size
();
h1
.resize
(n
+1,0
); h2
.resize
(n
+1,0
);
hr1
.resize
(n
+2,0
); hr2
.resize
(n
+2,0
); // 反向，从后往前
pw1
.resize
(n
+1,1
); pw2
.resize
(n
+1,1
);
for
(int i=1; i<=n; i
++) {
pw1[i] = pw1[i-1]*base % mod1;
pw2[i] = pw2[i-1]*base % mod2;
}
for
(int i=0; i<n; i
++) {
h1[i
+1] =
(h1[i]*base
+ s[i]
) % mod1;
h2[i
+1] =
(h2[i]*base
+ s[i]
) % mod2;
}
for
(int i=n-1; i>=0; i--
) {
hr1[i
+1] =
(hr1[i
+2]*base
+ s[i]
) % mod1;
hr2[i
+1] =
(hr2[i
+2]*base
+ s[i]
) % mod2;
}
}
// 获取子串s[l
..r]的
哈希值（l,r从0开始）
HashPair get
(int l, int r
) {
long long hash1 =
(h1[r
+1] - h1[l] * pw1[r-l
+1] % mod1
+ mod1
) % mod1;
long long hash2 =
(h2[r
+1] - h2[l] * pw2[r-l
+1] % mod2
+ mod2
) % mod2;
return {hash1, hash2};
}
// 获取反向子串（即s[l
..r]反转后，相当于原串的s[r]s[r-1]
...s[l]）的
哈希值
// 注意：反向子串的
哈希值等于原串从l到r的逆序的
哈希值，而我们用hr数组计算的是从后往前的
哈希，所以：
// 子串s[l
..r]的反向的
哈希值，等于我们用hr数组计算：从l到r（正序）的逆序，即等于从r到l（倒序）的
哈希值，而hr数组是从后往前，所以：
// 实际上，子串s[l
..r]反转后的
哈希值，等于我们计算hr数组
中的子串[l
..r]的
哈希值（注意hr数组的定义：hr[i]表示从i到末尾的
字符串的逆序
哈希？）
// 我们hr数组的定义：hr1[i] =
(s[i-1]*base^
(0
) + s[i-2]*base^
(1
) + ... )? 不对，我们初始化时：
// for
(int i=n-1; i>=0; i--
) {
// hr1[i
+1] =
(hr1[i
+2]*base
+ s[i]
) % mod1;
// }
// 所以，hr1[i
+1]表示从位置i到末尾（即s[i
..n-1]）的
哈希值（正序）？不对，因为是从后往前算，所以hr1[i
+1]表示的是子串s[i
..n-1]反转后的
哈希值？不对。
// 实际上，我们计算的是：从位置i到末尾的
字符串，但是计算顺序是从末尾开始，所以hr1[i
+1] = s[i]
+ s[i
+1]*base
+ s[i
+2]*base^2
+ ... + s[n-1]*base^
(n-1-i
)
// 而子串s[l
..r]反转后的
哈希值应该是：s[r]
+ s[r-1]*base
+ ... + s[l]*base^
(r-l
)
// 而我们用hr数组计算：从l到r的
哈希值（用hr数组）应该是：hr1[l
+1] - hr1[r
+2]*pw1[r-l
+1] 吗？
// 注意：hr1[i
+1] = s[i]*base^0
+ s[i
+1]*base^1
+ ... + s[n-1]*base^
(n-1-i
)
// 所以，子串s[l
..r]反转后的
哈希值应该是：s[l]
+ s[l
+1]*base
+ ... + s[r]*base^
(r-l
) 吗？不对，反转后应该是：s[r]
+ s[r-1]*base
+ ... + s[l]*base^
(r-l
)
// 所以，我们需要的是：从r到l（逆序）的
哈希值，而hr数组计算的是从l到末尾（正序）的
哈希值（但方向是从l到n-1），所以不能直接得到从r到l（逆序）的
哈希值。
// 因此，我们重新考虑：我们不需要反向数组，因为子串s[l
..r]反转后的
哈希值，等于原串从r到l（即子串s[r
..l]）的
哈希值？但是方向是递减的。
// 实际上，我们可以用正向数组计算从r到l的
哈希值，但需要倒着乘：即
// hash = s[r] * base^
(0
) + s[r-1]*base^1
+ ... + s[l]*base^
(r-l
)
// 而我们hr1[i
+1] = s[i]
+ s[i
+1]*base
+ ... + s[n-1]*base^
(n-1-i
)
// 所以，如果我们要求s[l
..r]反转后的
哈希值，可以：
// hash1 =
(hr1[l
+1] - hr1[r
+2] * pw1[r-l
+1]
) % mod1 // 但是，这里hr1[l
+1]包含了s[l
..n-1]，而hr1[r
+2]包含了s[r
+1
..n-1]
// 所以，hash1 =
(hr1[l
+1] - hr1[r
+2] * pw1[r-l
+1]
) % mod1 表示 s[l]
+ s[l
+1]*base
+ ... + s[r]*base^
(r-l
)
// 但是，反转后的
哈希值应该是：s[r]
+ s[r-1]*base
+ ... + s[l]*base^
(r-l
) 吗？不对，反转后应该是：s[r]
+ s[r-1]*base
+ ... + s[l]*base^
(r-l
) 这个式子等于我们上面计算的hash1吗？不相等。
// 所以，我们换一种方法：直接比较子串s[l
..r]的正向
哈希和反向
哈希是否相等，即用正向数组计算s[l
..r]的
哈希值，用反向数组计算s[l
..r]的反向
哈希值（即原串中从r到l的
哈希值），然后比较。
// 我们定义：
// get_normal
(l,r
) = 子串s[l
..r]的正向
哈希值（从左到右）
// get_rev
(l,r
) = 子串s[l
..r]的反向
哈希值（即该子串反转后的
哈希值，等于从右到左的
哈希值）
// 而我们有反向数组hr，但是hr数组计算的是从该位置到末尾的
字符串的
哈希值（从左到右，但
字符串是从该位置到末尾）。所以，我们无法直接得到子串s[l
..r]的反向
哈希值。
// 因此，我们重新设计
哈希数组：使用
两个数组，一个正向，一个反向（存储整个
字符串的反转的
哈希？）
// 或者，我们直接计算：反向
哈希数组定义为从后往前的正向
哈希，即：
// h_rev1[i] = s[i]*base^0
+ s[i-1]*base^1
+ ... 这样不方便。
// 另一种方法：我们使用一个技巧，将子串s[l
..r]反转后的
哈希值，等于正向计算子串s[l
..r]的
哈希值（但字符顺序反转）？我们可以用另一个
哈希数组，存储原
字符串反转后的
字符串的
哈希。
// 即，令rs = reverse
(s
)，然后计算rs的
哈希数组，那么子串s[l
..r]反转后的
哈希值等于rs中从n-1-r到n-1-l的子串的正向
哈希值。
// 因此，我们可以为每个
字符串s（包括rt和查询s）做
两个哈希数组：一个为原串，一个为反转串。
// 这样，判断子串s[l
..r]是否
回文，等价于：原串的子串s[l
..r]的
哈希值等于反转串的子串rs[n-1-r, n-1-l]的
哈希值。
// 但是，这样我们需要
两个哈希数组，而且空间和时间加倍。
// 实际上，我们只需要一个
哈希数组，然后利用一个公式计算子串反转后的
哈希值：
// 设子串s[l
..r]的
哈希值为H，而反转后的子串的
哈希值H'，可以通过反转串rs的
哈希数组得到：H' = rs_hash
(n-1-r, n-1-l
)
// 所以，我们可以这样：在StringHash结构中，同时存储原串和反转串的
哈希数组？但是，题目总长度20万，所以空间可以接受。
// 但是，在插入时，我们需要对每个rt判断其任意后缀是否
回文，而rt的长度可能很大，但总长度20万，所以可以。
// 因此，我们修改StringHash，使其可以同时计算原串和反转串的
哈希。
// 但是，为了简单，我们直接使用
两个哈希数组：一个用于原串（正向计算），另一个用于反转串（正向计算反转串）。
// 具体：
// struct StringHash {
// string s;
// int n;
// vector<long long> h1, h2, r_h1, r_h2;
// vector<long long> pw1, pw2;
// void init
(string str
) {
// s = str;
// n = s
.size
();
// // 初始化数组
// h1
.resize
(n
+1,0
); h2
.resize
(n
+1,0
);
// string rs = str;
// reverse
(rs
.begin
(), rs
.end
());
// r_h1
.resize
(n
+1,0
); r_h2
.resize
(n
+1,0
);
// pw1
.resize
(n
+1,1
); pw2
.resize
(n
+1,1
);
// for
(int i=1; i<=n; i
++) {
// pw1[i] = pw1[i-1]*base % mod1;
// pw2[i] = pw2[i-1]*base % mod2;
// }
// for
(int i=0; i<n; i
++) {
// h1[i
+1] =
(h1[i]*base
+ s[i]
) % mod1;
// h2[i
+1] =
(h2[i]*base
+ s[i]
) % mod2;
// r_h1[i
+1] =
(r_h1[i]*base
+ rs[i]
) % mod1;
// r_h2[i
+1] =
(r_h2[i]*base
+ rs[i]
) % mod2;
// }
// }
// HashPair get
(int l, int r
) {
// long long hash1 =
(h1[r
+1] - h1[l]*pw1[r-l
+1] % mod1
+ mod1
) % mod1;
// long long hash2 =
(h2[r
+1] - h2[l]*pw2[r-l
+1] % mod2
+ mod2
) % mod2;
// return {hash1, hash2};
// }
// HashPair get_rev
(int l, int r
) {
// // 反转子串的
哈希值，等于反转串中对应位置的子串的正向
哈希值
// // 原串s[l
..r]反转后，对应反转串rs
中的位置：l对应rs
中的n-1-l，r对应rs
中的n-1-r，所以子串为rs[n-1-r, n-1-l]?
// // 注意：反转串rs的下标：rs[0] = s[n-1], rs[1]=s[n-2],
... , rs[i]=s[n-1-i]
// // 所以，原串s[l
..r]反转后，等于rs[n-1-r]
... rs[n-1-l]
// int rev_l = n-1-r;
// int rev_r = n-1-l;
// long long hash1 =
(r_h1[rev_r
+1] - r_h1[rev_l]*pw1[rev_r-rev_l
+1] % mod1
+ mod1
) % mod1;
// long long hash2 =
(r_h2[rev_r
+1] - r_h2[rev_l]*pw2[rev_r-rev_l
+1] % mod2
+ mod2
) % mod2;
// return {hash1, hash2};
// }
// bool isPal
(int l, int r
) {
// if
(l>r
) return true;
// return get
(l,r
) == get_rev
(l,r
);
// }
// };
// 但是，这样比较
两个pair，如果相等则
回文。
// 注意：get_rev
(l,r
) 和 get
(l,r
) 应该满足：get_rev
(l,r
) = get
(l,r
) 当且仅当子串
回文？不对，get_rev
(l,r
)得到的是反转后的
哈希值，而get
(l,r
)是原串的
哈希值，它们相等当且仅当子串
回文。
// 所以，我们可以用这个isPal函数。
}
但是，这样空间和时间是两倍，但总长度20万，可以接受。
因此，我们采用这种方法。
最后，注意模数用大质数，base取131。
由于总长度小，也可以用自然溢出，但为了保险，用双模数。
代码实现较长，注意效率。
另外，
字典树节点：
struct Node {
Node* child[26];
int cnt1;
int cnt2;
Node
() {
for
(int i=0; i<26; i
++) child[i] = nullptr;
cnt1 = 0;
cnt2 = 0;
}
};
最后，注意：题目中
字符串由小写英文字母组成。
由于总长度20万，所以
字典树最多20万个节点，空间大约20万*26*指针大小？但我们可以用动态指针，而且实际不会每个节点都有26个孩子，所以空间可以接受。
但是，为了效率，我们可以用数组或vector，但指针方便。
注意：在查询时，我们判断s的剩余部分是否
回文，即从i
+1到末尾，所以调用isPal
(i
+1, s
.size
()-1
)。
另外，空串情况：在匹配过程中，如果i
+1==s
.size
()，那么剩余部分为空，我们认为是
回文。
所以，在循环中：
for
(int i=0; i<s
.size
(); i
++) {
int c = s[i]-'a';
if
(p->child[c]==nullptr
) break;
p = p->child[c];
if
(p->cnt1 > 0
) {
if
(i
+1 == s
.size
() || shash
.isPal
(i
+1, s
.size
()-1
)) {
ans
+= p->cnt1;
}
}
}
if
(i==s
.size
()) { // 匹配完了整个s
ans
+= p->cnt2;
}
这里，i是循环变量，如果break了，i不会等于s
.size
()，所以最后一句只有在匹配完整个s时才执行。
最后，注意：同一个t出现多次，所以用次数。
由于总
字符串长度20万，所以总复杂度O
(总长度
)=20万。
下面，我们写代码。
注意：在插入
字典树时，我们传入的
字符串是rt（即reverse
(t
)），而我们在插入时，已经计算了rt的
哈希，并判断了每个后缀是否
回文。
但是，在插入时，我们也要为rt计算
哈希（用于判断其后缀是否
回文），所以每个t（即rt）都要调用一次StringHash的init，而init的复杂度O
(len
(rt
))，总长度20万，所以总复杂度20万。
因此，整个程序复杂度O
(总长度
)=20万。
由于n,q最大20万，但总长度20万，所以平均
字符串长度很小，可以。
最后，注意：在
字典树中插入的总长度是20万（所有rt的长度和），查询的总长度也是20万（所有s的长度和），所以可行。
代码较长，注意细节。
由于时间限制1000ms，C
++可以完成。
下面给出完整代码。</think>### 解决方案
为了解决这个问题，我们需要高效地处理大量查询，统计
给定字符串集合中与查询
字符串拼接后形成
回文串的
字符串数量。核心思路是使用
字典树（Trie）和
字符串哈希技术，预处理
字符串信息，以便在查询时快速判断条件。
### 方法思路
1
. **问题分析**：
-
给定 `n` 个
字符串 `t` 和 `q` 个查询
字符串 `s`。
- 对于每个查询 `s`，需要统计有多少个 `t` 满足拼接
字符串 `s
+ t` 是
回文串。
- 拼接后形成
回文串的条件取决于 `s` 和 `t` 的长度关系：
- 当 `|s| >= |t|` 时，`t` 的反转必须等于 `s` 的前 `|t|` 个字符，且 `s` 的剩余部分必须是
回文串。
- 当 `|s| < |t|` 时，`t` 的后 `|s|` 个字符必须等于 `s` 的反转，且 `t` 的前 `|t| - |s|` 个字符必须是
回文串。
2
. **预处理**：
- **统计频率**：使用 `
map` 统计每个
字符串 `t` 出现的次数。
- **构建
字典树**：将每个 `t` 的反转
字符串 `rt` 插入
字典树。在插入过程中：
- 对于 `rt` 的每个前缀，判断剩余后缀是否为
回文串，并在相应树节点累加计数。
- 在树节点中记录完整 `rt`
字符串的计数（`cnt1`）和满足后缀
回文的计数（`cnt2`）。
3
. **查询处理**：
- 对于每个查询 `s`：
- 预处理 `s` 的正向和反向
哈希，用于快速判断子串
回文。
- 在
字典树中匹配 `s`：
- 在匹配过程中，如果当前节点是完整 `rt` 的结尾（`cnt1 > 0`），且 `s` 剩余部分为
回文，则累加 `cnt1`。
- 匹配完整个 `s` 后，累加当前节点的 `cnt2`（满足条件2的
字符串数量）。
4
. **优化**：
- **
字符串哈希**：使用双
哈希（
两个模数）减少冲突，确保
回文判断的准确性。
- **
字典树设计**：树节点包含
两个计数器（`cnt1` 和 `cnt2`），分别用于存储完整
字符串计数和满足后缀
回文的计数。
### 解决代码
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <
map>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> HashPair;
const ll mod1 = 1e9
+ 7;
const ll mod2 = 1e9
+ 9;
const ll base = 131;
struct StringHash {
string s;
int n;
vector<ll> h1, h2, r_h1, r_h2;
vector<ll> pw1, pw2;
void init
(string str
) {
s = str;
n = s
.size
();
h1
.assign
(n
+1, 0
);
h2
.assign
(n
+1, 0
);
r_h1
.assign
(n
+1, 0
);
r_h2
.assign
(n
+1, 0
);
pw1
.assign
(n
+1, 1
);
pw2
.assign
(n
+1, 1
);
for
(int i = 1; i <= n; i
++) {
pw1[i] = pw1[i-1] * base % mod1;
pw2[i] = pw2[i-1] * base % mod2;
}
for
(int i = 0; i < n; i
++) {
h1[i
+1] =
(h1[i] * base
+ (s[i] - 'a'
+ 1
)) % mod1;
h2[i
+1] =
(h2[i] * base
+ (s[i] - 'a'
+ 1
)) % mod2;
}
string rs = s;
reverse
(rs
.begin
(), rs
.end
());
for
(int i = 0; i < n; i
++) {
r_h1[i
+1] =
(r_h1[i] * base
+ (rs[i] - 'a'
+ 1
)) % mod1;
r_h2[i
+1] =
(r_h2[i] * base
+ (rs[i] - 'a'
+ 1
)) % mod2;
}
}
HashPair get
(int l, int r
) {
ll hash1 =
(h1[r
+1] - h1[l] * pw1[r-l
+1] % mod1
+ mod1
) % mod1;
ll hash2 =
(h2[r
+1] - h2[l] * pw2[r-l
+1] % mod2
+ mod2
) % mod2;
return {hash1, hash2};
}
HashPair get_rev
(int l, int r
) {
int rev_l = n - 1 - r;
int rev_r = n - 1 - l;
ll hash1 =
(r_h1[rev_r
+1] - r_h1[rev_l] * pw1[rev_r - rev_l
+ 1] % mod1
+ mod1
) % mod1;
ll hash2 =
(r_h2[rev_r
+1] - r_h2[rev_l] * pw2[rev_r - rev_l
+ 1] % mod2
+ mod2
) % mod2;
return {hash1, hash2};
}
bool isPal
(int l, int r
) {
if
(l > r
) return true;
return get
(l, r
) == get_rev
(l, r
);
}
};
struct Node {
Node* child[26];
int cnt1;
int cnt2;
Node
() {
for
(int i = 0; i < 26; i
++) child[i] = nullptr;
cnt1 = 0;
cnt2 = 0;
}
};
Node* root;
void insert
(string rt, int count
) {
StringHash shash;
shash
.init
(rt
);
Node* p = root;
for
(int i = 0; i < rt
.size
(); i
++) {
int c = rt[i] - 'a';
if
(p->child[c] == nullptr
) {
p->child[c] = new Node
();
}
p = p->child[c];
if
(shash
.isPal
(i, rt
.size
()-1
)) {
p->cnt2
+= count;
}
}
p->cnt1
+= count;
}
int main
() {
ios::sync_with_stdio
(false
);
cin
.tie
(0
);
int n, q;
cin >> n >> q;
map<string, int> count
Map;
vector<string> t_list
(n
);
for
(int i = 0; i < n; i
++) {
cin >> t_list[i];
count
Map[t_list[i]]
++;
}
root = new Node
();
for
(auto& p : count
Map) {
string t = p
.first;
string rt = t;
reverse
(rt
.begin
(), rt
.end
());
insert
(rt, p
.second
);
}
vector<string> s_list
(q
);
for
(int i = 0; i < q; i
++) {
cin >> s_list[i];
}
for
(int j = 0; j < q; j
++) {
string s = s_list[j];
StringHash shash;
shash
.init
(s
);
Node* p = root;
ll ans = 0;
int i;
for
(i = 0; i < s
.size
(); i
++) {
int c = s[i] - 'a';
if
(p->child[c] == nullptr
) {
break;
}
p = p->child[c];
if
(p->cnt1 > 0
) {
if
(i == s
.size
()-1 || shash
.isPal
(i
+1, s
.size
()-1
)) {
ans
+= p->cnt1;
}
}
}
if
(i == s
.size
()) {
ans
+= p->cnt2;
}
cout << ans << '\n';
}
return 0;
}
```
### 代码解释
1
. **StringHash 结构**：
- `init`：初始化
字符串的正向和反向
哈希数组，用于快速计算子串
哈希。
- `get`：计算子串 `[l, r]` 的正向
哈希值。
- `get_rev`：计算子串 `[l, r]` 的反向
哈希值（即反转后的
哈希）。
- `isPal`：判断子串 `[l, r]` 是否为
回文串。
2
. **
字典树操作**：
- `insert`：将
字符串 `rt`（`t` 的反转）插入
字典树。在插入过程中，对每个前缀判断剩余后缀是否为
回文，并在树节点累加计数。
- 树节点包含 `cnt1`（完整 `rt`
字符串计数）和 `cnt2`（满足后缀
回文的计数）。
3
. **查询处理**：
- 对于每个查询 `s`：
- 初始化
哈希，用于快速判断子串
回文。
- 在
字典树中匹配 `s`：
- 匹配过程中，若当前节点是完整 `rt` 的结尾且 `s` 剩余部分
回文，累加 `cnt1`。
- 匹配完整个 `s` 后，累加 `cnt2`（满足条件2的
字符串数量）。
- 输出结果。
### 相关的问题
1
. 如何优化
字典树的空间复杂度？
2
. 双
哈希相比单
哈希有哪些优势？
3
. 如何处理
字符串拼接后形成
回文串的其他变体问题？
4
. 在
字典树中，如何支持动态插入和删除操作？
给定唯一单词列表，找出所有单词对(i, j)，使words[i]+words[j]组成回文串。解题方法包括暴力法（超时）和字典树法。使用字典树，分别查找与自身相反、回文前缀子串和回文后缀子串的组合，关键在于确保分类涵盖所有情况。"
128673251,11441506,实在智能RPA 6.6.0发布：IPA模式开启RPA全民时代,"['RPA', '自动化工具', '人工智能', '零代码开发', '国产软件']
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
