DFA Minimization

有点晚了我就不调试了..不过说是这么说我还是过了编译的..

#include<bits/stdc++.h>
using namespace std;
namespace DFA{
   const int alp=10;
   struct Node{int t[alp],a;Node(){}Node(int tx,int ac):a(ac){for(int i=0;i<alp;++i)t[i]=tx;}};
   struct DFA{
      vector<Node>nodes;
      int starting;
      int crt(int ac=0){nodes.emplace_back(nodes.size(),ac);}
      void ss(int s){starting=s;}
      void st(int s,int c,int t){nodes[s].t[c]=t;}
      void sa(int s,int a){nodes[s].a=a;}
   };
   int _C_u_dd(vector<int>&a,const DFA&tt,int pos,int up){
      a[pos]=up++;
      const Node&g=tt.nodes[pos];
      for(int i=0;i<alp;++i)if(!a[g.t[i]])
         up=_C_u_dd(a,tt,g.t[i],up);
      return up;
   }
   int Cut_unreachable(DFA&cc,const DFA&tt){
      cc.nodes.clear();
      vector<int>z;
      z.resize(tt.nodes.size());
      int gr=_C_u_dd(z,tt,tt.starting,1);
      cc.nodes.resize(gr);
      for(int i=0,_=tt.nodes.size();i<_;++i)if(z[i]){
         const Node&p=tt.nodes[i];
         Node&q=cc.nodes[z[i]];
         q.a=p.a;
         for(int i=0;i<alp;++i)
            q.t[i]=z[p.t[i]];
      }cc.ss(1);
      return gr-1;
   }
   namespace PRS{
      struct q{
         vector<int>son;int tid,in;
         q(int sz=0):tid(-1){if(sz)son.resize(sz);}
      };
      typedef pair<int,int>o;
      struct p{
         vector<q>z;
         vector<o>b;
         p(int t){
            z.emplace_back(t);
            b.resize(t+1);
            for(int i=0;i<t;++i)
               b[i+1]=o(0,i),z[0].son[i]=i+1;
         }
         void _reassign(q&a,int s){
            q&t=z[a.tid];
            int id=a.son[s];
            if(s!=a.son.size()-1){
               int idr=a.son[a.son.size()-1];
               b[idr].second=s;
               swap(a.son[s],a.son[a.son.size()-1]);
            }a.son.pop_back();
            b[id]=o(a.tid,t.son.size());
            t.son.push_back(id);
         }
         vector<o>split(vector<int>t){
            vector<o>q;
            for(int v:t){
               if(z[b[v].first].tid==-1){
                  q.emplace_back(b[v].first,z.size());
                  z[b[v].first].tid=z.size(),z.emplace_back();
               }_reassign(z[b[v].first],b[v].second);
            }for(o g:q)
               z[g.first].tid=-1;
            return q;
         }
      };
   }
   typedef vector<int> inlist[alp];
   void DFA_Minimize(DFA&tt){
      DFA gg;
      int si=Cut_unreachable(gg,tt);
      PRS::p pr(si);
      vector<int>vi;
      inlist*inl=new inlist[si+1];
      for(int i=1;i<=si;++i){
         for(int j=0;j<alp;++j)
            inl[gg.nodes[i].t[j]][j].push_back(i);
         if(gg.nodes[i].a)
            vi.push_back(i);
      }auto gd=pr.split(vi)[0];
      stack<int>sets;
      sets.push(gd.second);
      pr.z[gd.second].in=1;
      while(!sets.empty()){
         int setNow=sets.top();sets.pop();
         pr.z[setNow].in=0;
         vector<int>qs;
         for(int i:pr.z[setNow].son)
            qs.push_back(i);
         for(int j=0;j<alp;++j){
            vi.clear();
            for(int i:qs)
               for(int k:inl[i][j])
                  vi.push_back(k);
            auto qt=pr.split(vi);
            for(auto i:qt)
               if(pr.z[i.first ].son.size()&&
                  pr.z[i.second].son.size())
                  if(pr.z[i.first ].in||
                     pr.z[i.first ].son.size()>
                     pr.z[i.second].son.size())
                     sets.push(i.second),pr.z[i.second].in=1;
                  else sets.push(i.first),pr.z[i.first].in=1;
         }
      }int id=1;
      for(auto i:pr.z)if(i.son.size())
         i.in=id++;
      tt.nodes.resize(id);
      for(auto i:pr.z)if(i.son.size()){
         Node&q=tt.nodes[i.in];
         Node&u=gg.nodes[i.son[0]];
         for(int j=0;j<alp;++j)
            q.t[j]=pr.z[pr.b[u.t[j]].first].in;
      }tt.starting=pr.z[pr.b[1].first].in;
      delete[]inl;
   }
}
int main(){
   return 0;
}

最后祝您身体健康,再见.