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;
}