hdu 4511 (AC自动机)

注意标记一个点后，fail树上的子节点都会被标记

跑spfa，dp也可以

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include <set>
#include <queue>
#define ll long long
#define ld long double
#define lson l,m,rt<<1
#define pi acos(-1)
#define rson m+1,r,rt<<1|1
#define fo(i,l,r) for(int i = l;i <= r;i++)
#define fd(i,l,r) for(int i = r;i >= l;i--)
#define mem(x) memset(x,0,sizeof(x))
#define eps 1e-8
using namespace std;
const int maxn = ;
const ll inf = 1e9;
const ll mod = ;
ll read() {
    ll x=,f=;
    char ch=getchar();
    while(!(ch>=''&&ch<='')) {
        if(ch=='-')f=-;
        ch=getchar();
    };
    while(ch>=''&&ch<='') {
        x=x*+(ch-'');
        ch=getchar();
    };
    return x*f;
}
struct Trie{
    int nxt[maxn][],fail[maxn],end[maxn];
    int root,L;
    int newnode(){
        for(int i = ;i < ;i++)
            nxt[L][i] = -;
        end[L++]=;
        return L-;
    }
    void init(){
        L = ;
        root = newnode();
    }
    void insert(char buf[],bool bj){
        int len = strlen(buf);
        int now = root;
        for(int i = ;i < len;i++){
            if(nxt[now][buf[i]]==-)
                nxt[now][buf[i]] = newnode();
            now = nxt[now][buf[i]];
        }
        if(bj)end[now]++;
    }
    void build(){
        queue<int> Q;
        fail[root] = root;
        for(int i = ;i < ;i++) {
            if (nxt[root][i] == -) {
                nxt[root][i] = root;
            } else {
                fail[nxt[root][i]] = root;
                Q.push((nxt[root][i]));
            }
        }
        while(!Q.empty()){
            int now = Q.front();
            Q.pop();
            if(end[fail[now]]) end[now]=;
            for(int i = ;i < ;i++){
                if(nxt[now][i]==-) {
                    nxt[now][i] = nxt[fail[now]][i];
                }else{
                    fail[nxt[now][i]] = nxt[fail[now]][i];
                    Q.push(nxt[now][i]);
                }
            }
        }
    }
}ac;
int n,m,k;
double xx[maxn],yy[maxn];
char s[];
struct dat{
    int u;
    int v;
    double dis;
}now,nxt;
vector<dat> g[][];
double d[][];
bool vis[][];
double ans;
void spfa(){
    queue<dat> q;
    fo(i,,ac.L-){
        fo(j,,n){
            vis[i][j]=false;
            d[i][j]=-100.0;
        }
    }
    now.u = ac.nxt[][];now.v=;
    q.push(now);
    vis[now.u][]=true;d[now.u][]=0.0;
    while(!q.empty()){
        now = q.front();
        q.pop();
        for(dat t:g[now.u][now.v]){
            if(d[t.u][t.v]<||(d[now.u][now.v]+t.dis<d[t.u][t.v])){
                d[t.u][t.v] = d[now.u][now.v]+t.dis;
                if(!vis[t.u][t.v]){
                    vis[t.u][t.v]=true;
                    q.push(t);
                }
            }
        }
        if(now.v==n){
            if(ans<||d[now.u][now.v] <ans)ans=d[now.u][now.v];
        }
        vis[now.u][now.v]=false;
    }

}
int main() {
    while(true){
        ac.init();
        ans=-1.0;
        n=read();m=read();
        if(!n&&!m)break;
        fo(i,,n){
            xx[i]=read();yy[i]=read();
        }
        fo(i,,m){
            k=read();
            int t;
            fo(j,,k){
                t=read();
                s[j-]=t;
            }
            s[k]='\0';
            ac.insert(s,true);
        }
        ac.build();
        int v;

        fo(i,,ac.L-){
            fo(j,,n) g[i][j].clear();
            fo(j,,n){
                v=ac.nxt[i][j];
                if(ac.end[v])continue;
                now.u = v;
                now.v = j;
                fo(k,,n){
                    if(k>=j)continue;
                    now.dis = sqrt((xx[j]-xx[k])*(xx[j]-xx[k]) + (yy[j]-yy[k])*(yy[j]-yy[k]));
                    g[i][k].push_back(now);
                }
            }
        }
        spfa();
        if(fabs(ans)<eps)ans=;
        if(ans<-eps)puts("Can not be reached!");
        else printf("%.2f\n",ans);
    }
    return ;
}