bzoj 1779

较水的网络流。

 /**************************************************************
     Problem: 1779
     User: idy002
     Language: C++
     Result: Accepted
     Time:36 ms
     Memory:1520 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <queue>
 #define maxn 4010
 #define fprintf(...)
 #define oo 0x3f3f3f3f
 using namespace std;

 struct Edge {
     int u, v, f;
     Edge( int u, int v, int f ):u(u),v(v),f(f){}
 };
 struct Dinic {
     int src, dst;
     vector<Edge> edge;
     vector<int> g[maxn];
     int dep[maxn], cur[maxn];

     void init( int src, int dst ) {
         this->src = src;
         this->dst = dst;
     }
     void adde( int u, int v, int f ) {
         fprintf( stderr, "%d->%d %d\n", u, v, f );
         g[u].push_back( edge.size() );
         edge.push_back( Edge(u,v,f) );
         g[v].push_back( edge.size() );
         edge.push_back( Edge(v,u,) );
     }
     bool bfs() {
         queue<int> qu;
         memset( dep, , sizeof(dep) );
         qu.push( src );
         dep[src] = ;
         while( !qu.empty() ) {
             int u=qu.front();
             qu.pop();
             for( int t=; t<g[u].size(); t++ ) {
                 Edge &e = edge[g[u][t]];
                 if( e.f && !dep[e.v] ) {
                     dep[e.v] = dep[e.u]+;
                     qu.push( e.v );
                 }
             }
         }
         return dep[dst];
     }
     int dfs( int u, int a ) {
         if( u==dst || a== ) return a;
         int remain=a, past=, na;
         for( int &t=cur[u]; t<g[u].size(); t++ ) {
             Edge &e = edge[g[u][t]];
             Edge &ve = edge[g[u][t]^];
             if( dep[e.v]==dep[e.u]+ && e.f && (na=dfs(e.v,min(e.f,remain))) ) {
                 remain -= na;
                 past += na;
                 e.f -= na;
                 ve.f += na;
                 if( remain== ) break;
             }
         }
         return past;
     }
     int maxflow() {
         int flow=;
         while( bfs() ) {
             memset( cur, , sizeof(cur) );
             flow += dfs(src,oo);
         }
         return flow;
     }
 }D;

 int n, m;
 vector<int> g[maxn];
 int cnt[maxn];
 char stat[maxn];
 int idj[maxn], idt[maxn], ide[maxn][];

 void makeid( int &src, int &dst ) {
     int id_clock = ;
     src = ++id_clock;
     dst = ++id_clock;
     fprintf( stderr, "src=%d dst=%d\n", src, dst );
     for( int i=; i<=n; i++ )  {
         if( stat[i]=='J' ) {
             idj[i] = ++id_clock;
             fprintf( stderr, "idj[%d] = %d\n", i, idj[i] );
         } else if( stat[i]=='T' ) {
             idt[i] = ++id_clock;
             fprintf( stderr, "idt[%d] = %d\n", i, idt[i] );
         }
         if( stat[i]!='T' ) {
             ide[i][] = ++id_clock;
             ide[i][] = ++id_clock;
             fprintf( stderr, "ide[%d][0] = %d\n", i, ide[i][] );
             fprintf( stderr, "ide[%d][1] = %d\n", i, ide[i][] );
         }
     }
 }
 int main() {
     scanf( "%d%d", &n, &m );
     scanf( "%s", stat+ );
     for( int i=; i<=n; i++ )
         cnt[i] = cnt[i-]+(stat[i]=='E');
     for( int i=,u,v; i<=m; i++ ) {
         scanf( "%d%d", &u, &v );
         g[u].push_back(v);
         g[v].push_back(u);
     }
     int src, dst;
     makeid( src, dst );
     D.init( src, dst );
     for( int i=; i<=n; i++ ) {
         if( stat[i]=='J' ) {
             D.adde( src, idj[i],  );
             D.adde( idj[i], ide[i][],  );
             for( int t=; t<g[i].size(); t++ ) {
                 int j=g[i][t];
                 if( stat[j]=='T' ) continue;
                 D.adde( idj[i], ide[j][],  );
             }
         } else if( stat[i]=='T' ) {
             D.adde( idt[i], dst,  );
             for( int t=; t<g[i].size(); t++ ) {
                 int j=g[i][t];
                 if( stat[j]=='T' ) continue;
                 D.adde( ide[j][], idt[i],  );
             }
         }
         if( stat[i]!='T' ) {
             D.adde( ide[i][], ide[i][],  );
         }
     }
     printf( "%d\n", D.maxflow() );
 }