18.9.2开学模拟题解

好久没有模拟了，然后一模拟就gg……

 

T1 高维宇宙

　　因为模拟标题上写的noip，所以当时我就压根没往二分图匹配想，而是生成了了一个像邻接矩阵的表，t[i][j]表示 a[i] + a[j]，然后在倒三角矩阵里爆搜……虽然加上了如果加上当前最大值仍小于ans就返回的剪枝，但还是稳稳地30分……果然搜索的复杂度不可预料啊。

　　正解嘛，因为题中说到了匹配，那自然是二分图匹配或网络流了。因此重在建图：首先必须满足是二分图，那么想一想就得出，一定是一个奇数和一个偶数相加才可能得到一个质数。因此二分图就建成了：一半是偶数，一般是奇数，然后把偶数都连一条流量为1通向源点的边，奇数连一条通向汇点的边，然后如果两数之和为质数，就连边。

　　跑网络流或匈牙利就行了~~

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a) memset(a, 0, sizeof(a))
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int max_num = 2e3 + 5; 
const int maxn = 45;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, t, a[maxn];
bool prime[max_num] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0};

struct Edge
{
    int from, to, cap, flow;
};
vector<Edge> edges;
vector<int> G[maxn << 2];
void addedge(int from, int to)
{
    edges.push_back((Edge){from, to, 1, 0});
    edges.push_back((Edge){to, from, 0, 0});
    int sz = edges.size();
    G[from].push_back(sz - 2);
    G[to].push_back(sz - 1);
}

int dis[maxn << 2];
bool vis[maxn << 2];
bool bfs()
{
    Mem(vis);
    queue<int> q;
    q.push(0); vis[0] = 1;
    dis[0] = 0;
    while(!q.empty())
    {
        int now = q.front(); q.pop();
        for(int i = 0; i < (int)G[now].size(); ++i)
        {
            Edge& e = edges[G[now][i]];
            if(!vis[e.to] && e.cap > e.flow)
            {
                vis[e.to] = 1;
                dis[e.to] = dis[now] + 1;
                q.push(e.to);
            }
        }
    }
    return vis[t];
}
int cur[maxn << 2];
int dfs(int now, int a)
{
    if(now == t || !a) return a;
    int flow = 0, f;
    for(int& i = cur[now]; i < (int)G[now].size(); ++i)
    {
        Edge& e = edges[G[now][i]];
        if(dis[e.to] == dis[now] + 1 && (f = dfs(e.to, min(a, e.cap - e.flow))) > 0)
        {
            e.flow += f;
            edges[G[now][i] ^ 1].flow -= f;        
            flow += f; a -= f;
            if(!a) break;    
        }
    }
    return flow;
}

int maxflow()
{
    int flow = 0;
    while(bfs())
    {
        Mem(cur);
        flow += dfs(0, INF);
    }
    return flow;
}

int main()
{
    freopen("prime.in", "r", stdin);
    freopen("prime.out", "w", stdout);
    n = read(); t = n + n + 1;
    for(int i = 1; i <= n; ++i) a[i] = read();
    for(int i = 1; i <= n; ++i)
    {
        if(!(a[i] & 1)) addedge(0, i);
        else addedge(i + n, t);
        if(!(a[i] & 1)) for(int j = 1; j <= n; ++j)
            if(prime[a[i] + a[j]]) addedge(i, n + j);
    }
    write(maxflow()); enter;
    return 0;
}

T2 旅行

　　这道题模拟的时候看错了……看成可以同时走很多边，像网络流那种。然而题中明确的说出是只能选一条路径，要不然“（若有多组解取字典序最小的一组 )”这句话干啥……

　　按我错误的理解，我就先正着bfs一遍，再反着bfs一遍，然后两次都标记的点就是在1到n路径上的点，然后对于这些点连的边的[L, R]，用线段树维护即可。（虽然题意理解错了，但我觉得我这算法挺完美的）

　　正解我写的是一种比较诡异的dijkstra，interestingLSY大佬给我讲的。首先我们从小到大枚举L，然后把所有a[i].L <= L <= a[i].R的边都加入图中构成一个新的图，换句话说就是把可能使L成为答案的边加入图中。然后在这个图上跑dijkstra（或者更像是dp）：令dis[i]表示到结点 i 满足条件的R的最大值，则当执行u到v的松弛操作时，dis[v] = min(dis[u], a[u->v].R)。那么最后的dis[n]就是当答案，用dis[n] - L尝试去更新最终的答案。

　　这时会有人问：因为我们加入的边只是满足a[i].L <= L <= a[i].R，所以实际上dis[n] - L可能不是最优的答案，可能是某一个的a[i].L。这不成问题，因为这种情况一定会在枚举更小的L的时候考虑到。

　　代码实现上其实不用反复建图，只用判断当前的边是否符合条件，如符合，就加入优先队列。

　

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a) memset(a, 0, sizeof(a))
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 1e3 + 5;
const int maxm = 3e3 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m, l[maxm];
struct Node
{
    int to, L, R;
};
vector<Node> v[maxn];

#define pr pair<int, int> 
#define mp make_pair 
int dis[maxn];
bool in[maxn];
int dijkstra(int l)
{
    Mem(in); Mem(dis);
    dis[1] = INF;         //dis[1]要初始化为INF 
    priority_queue<pr> q;
    q.push(mp(dis[1], 1));
    while(!q.empty())
    {
        int now = q.top().second; q.pop();
        if(in[now]) continue;
        in[now] = 1;
        for(int i = 0; i < (int)v[now].size(); ++i)
        {
            if(v[now][i].L <= l && l <= v[now][i].R && dis[v[now][i].to] < min(dis[now], v[now][i].R))    //注意条件 
            {
                dis[v[now][i].to] = min(dis[now], v[now][i].R);
                q.push(mp(dis[v[now][i].to], v[now][i].to));
            }
        }
    }
    return dis[n];
}

int lft = 0, rgt = 0;

int main()
{
    freopen("travel.in", "r", stdin);
    freopen("travel.out", "w", stdout);
    n = read(); m = read();
    for(int i = 1; i <= m; ++i)
    {
        int x = read(), y = read(), L = read(), R = read();
        l[i] = L;
        v[x].push_back((Node){y, L, R}); v[y].push_back((Node){x, L, R});
    }
    sort(l + 1, l + m + 1);
    int _m = unique(l + 1, l + m + 1) - l - 1;
    for(int i = 1; i <= _m; ++i)
    {
        int R = dijkstra(l[i]);
        if(R - l[i] > rgt - lft) lft = l[i], rgt = R;
    }
    write(rgt - lft + 1); enter; 
    if(!lft && !rgt) return 0;
    for(int i = lft; i <= rgt; ++i) write(i), space; enter;
    return 0;
}

T3 词典

　　这道题第一反应是hash，然后发现是一个很稳的O(n²)做法只能得30分。然后就想到了trie树，但是实在没想出来如何去维护a数组，就打算30分跑路了，结果MLE，哎nb！没想到忘算空间复杂度了。不过这幸亏发生在平时的模拟上，给我这个教训，而不是noip现场上……

　　标程实际上是在trie树上每一个结点开了一个vector，记录第几个字符串经过该点，然后查询的时候到结点 i，就遍历nd[i]（nd是vector），暴力更新答案。然而这么会TLE，不过只要再开一个vis数组，求过的点就不用再求了。复杂度最坏最坏好像是O(∑len_s * n)，n是遍历vector的复杂度。不过实际上远远没有达到这个地步，因为字母只有a, b, c，所以n个字符串中公用的结点会很多，查询到相同的结点的概率会很大，所以实际上遍历vector的复杂度远小于n。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a) memset(a, 0, sizeof(a))
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 5e6 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m;
int ch[maxn][3], tot = 0;
vector<int> nd[maxn];
int vis[maxn];
void insert(int id, char* s)
{
    int m = strlen(s), now = 0;
    for(int i = 0; i < m; ++i)
    {
        int c = s[i] - 'a';
        if(!ch[now][c]) ch[now][c] = ++tot;
        now = ch[now][c];
        nd[now].push_back(id);
    }
}
int query(char *s)
{
    int m = strlen(s), now = 0;
    for(int i = 0; i < m; ++i)
    {
        int c = s[i] - 'a';
        if(!ch[now][c]) return n;
        now = ch[now][c];
    }
    if(vis[now]) return vis[now];
    int Max = nd[now][0] - 1;
    for(int i = 1; i < (int)nd[now].size(); ++i) Max = max(Max, nd[now][i] - nd[now][i - 1] - 1);
    return vis[now] = max(Max, n - nd[now][nd[now].size() - 1]);
}

char s[maxn];

int main()
{
    freopen("word.in", "r", stdin);
    freopen("word.out", "w", stdout);
    n = read(); m = read();
    for(int i = 1; i <= n; ++i) {scanf("%s", s); insert(i, s);}
    for(int i = 1; i <= m; ++i)
    {
        scanf("%s", s);
        write(query(s)); enter;
    }
    return 0;
}

　　然而今天不知是谁想出了更强的算法。就是每一个节点维护一个Max[i]：代表结点 i能达到的最长连续 0的长度，las[i]代表trie树上最后经过结点 i 的是第几个字符串。las[i]当然是为了求Max[i]服务的，在建树过程中，用当前的字符串id，就可以更新Max[i] = max(Max[i], id - las[i] - 1),然后las[i] = id。

　　这样就优化到了O(∑len_t)预处理，O(∑len_s)查询。

优化后的代码：

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a) memset(a, 0, sizeof(a))
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 5e6 + 5;
inline ll read()
{
    ll ans = 0;
    char ch = getchar(), last = ' ';
    while(!isdigit(ch)) {last = ch; ch = getchar();}
    while(isdigit(ch)) {ans = ans * 10 + ch - '0'; ch = getchar();}
    if(last == '-') ans = -ans;
    return ans;
}
inline void write(ll x)
{
    if(x < 0) x = -x, putchar('-');
    if(x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

int n, m;
int ch[maxn][3], las[maxn], Max[maxn], tot = 0;
void insert(int id, char* s)
{
    int m = strlen(s), now = 0;
    for(int i = 0; i < m; ++i)
    {
        int c = s[i] - 'a';
        if(!ch[now][c]) ch[now][c] = ++tot;
        now = ch[now][c];
        Max[now] = max(Max[now], id - las[now] - 1);
        las[now] = id;
        
    }
}
int query(char *s)
{
    int m = strlen(s), now = 0;
    for(int i = 0; i < m; ++i)
    {
        int c = s[i] - 'a';
        if(!ch[now][c]) return n;
        now = ch[now][c];
    }
    return max(Max[now], n - las[now]);
}

char s[maxn];

int main()
{
    freopen("word.in", "r", stdin);
    freopen("word.out", "w", stdout);
    n = read(); m = read();
    for(int i = 1; i <= n; ++i) {scanf("%s", s); insert(i, s);}
    for(int i = 1; i <= m; ++i)
    {
        scanf("%s", s);
        write(query(s)); enter;
    }
    return 0;
}

最后吐槽：最惨的还是MLE，算是吸取个教训了……