BZOJ 1194 HNOI2006 潘多拉的盒子 BFS+Tarjan+拓扑序DP

题目大意：给定一些自动机，如果某个自动机 A 能产生的所有串都能在自动机 B 中产生，则称 B 是 A 的一个升级，求最长链
这题TM有毒
数据范围 50 ，暴力枚举每一对点之间的关系，然后Tarjan缩点求最长链就行了
现在对于一对自动机 A 和 B ,我想知道 A 能产生的所有串是否都能在 B 中产生，那么BFS就可以了
我们用一个二元组 (x,y) 表示走了某个串后 A 走到了节点 x ， B 走到了节点 y ，那么如果 x 是输出节点而 y 不是，则不满足条件，否则继续广搜 (x,y) 的两个后继
由于这样的二元组 (x,y) 只有 O(n2) 个，因此标记一下，单次判断的复杂度就是 O(n2) 的了

#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 55
using namespace std;
struct abcd{
    int to,next;
}table[M*M];
int head[M],tot;
int n,cnt;
bool v[M];
int belong[M];
vector<int> member[M];
int f[M],ans;
void Add(int x,int y)
{
    table[++tot].to=y;
    table[tot].next=head[x];
    head[x]=tot;
}
struct Automaton{
    int n,m;
    int trans[M][2];
    bool outlet[M];
    void Read()
    {
        int i,x;
        cin>>n>>m;
        for(i=1;i<=m;i++)
        {
            scanf("%d",&x);
            outlet[x]=true;
        }
        for(i=0;i<n;i++)
            scanf("%d%d",&trans[i][0],&trans[i][1]);
    }
}a[M];
bool BFS(const Automaton &x,const Automaton &y)
{
    static pair<int,int> q[65540];
    static bool v[M][M];
    int i,r=0,h=0;
    memset(v,0,sizeof v);
    q[++r]=make_pair(0,0);v[0][0]=true;
    while(r!=h)
    {
        pair<int,int> sta=q[++h];
        if( x.outlet[sta.first] && !y.outlet[sta.second] )
            return false;
        for(i=0;i<2;i++)
        {
            int xx=x.trans[sta.first][i];
            int yy=y.trans[sta.second][i];
            if(v[xx][yy]) continue;
            v[xx][yy]=true;
            q[++r]=make_pair(xx,yy);
        }
    }
    return true;
}
void Tarjan(int x)
{
    static int stack[M],top;
    static int dpt[M],low[M],T;
    int i;
    stack[++top]=x;
    dpt[x]=low[x]=++T;
    for(i=head[x];i;i=table[i].next)
    {
        if(v[table[i].to])
            continue;
        if(dpt[table[i].to])
            low[x]=min(low[x],dpt[table[i].to]);
        else
            Tarjan(table[i].to),low[x]=min(low[x],low[table[i].to]);
    }
    if(dpt[x]==low[x])
    {
        int t;++cnt;
        do{
            t=stack[top--];
            belong[t]=cnt;
            member[cnt].push_back(t);
            v[t]=true;
        }while(t!=x);
    }
}
void Topology_Sort()
{
    static int q[M],degree[M];
    int i,j,r=0,h=0;
    for(j=1;j<=n;j++)
        for(i=head[j];i;i=table[i].next)
            if(belong[table[i].to]!=belong[j])
                degree[belong[table[i].to]]++;
    for(i=1;i<=cnt;i++)
        if(!degree[i])
            q[++r]=i;
    while(r!=h)
    {
        j=q[++h];
        vector<int>::iterator it;
        f[j]+=member[j].size();
        for(it=member[j].begin();it!=member[j].end();it++)
        {
            int x=*it;
            for(i=head[x];i;i=table[i].next)
            {
                if(belong[table[i].to]==j)
                    continue;
                f[belong[table[i].to]]=max(f[belong[table[i].to]],f[j]);
                if(!--degree[belong[table[i].to]])
                    q[++r]=belong[table[i].to];
            }
        }
        ans=max(ans,f[j]);
    }
}
int main()
{
    int i,j;
    cin>>n;
    for(i=1;i<=n;i++)
        a[i].Read();
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            if( i!=j && BFS(a[i],a[j]) )
                Add(i,j);
    for(i=1;i<=n;i++)
        if(!v[i])
            Tarjan(i);
    Topology_Sort();
    cout<<ans<<endl;
    return 0;
}