hdu 1565 最小割

黑白染色，源指向白，黑指向汇，容量都是方格中数的大小，相邻的格子白指向黑，容量为oo，然后求一次最小割。

这个割是一个简单割，如果只选择不在割中的点，那么一种割就和一个选数方案一一对应，割的大小就是不选的那些数的大小，我们需要最小化这个值。

答案=总和-最小割

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <vector>
 #define maxn 410
 #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 n, src, dst;
     vector<Edge> edge;
     vector<int> g[maxn];
     int dep[maxn], cur[maxn];

     void init( int n, int src, int dst ) {
         this->n = n;
         this->src = src;
         this->dst = dst;
         for( int u=; u<=n; u++ )
             g[u].clear();
         edge.clear();
     }
     void add_edge( int u, int v, int 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(remain,e.f))) ) {
                 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;
     }
 };

 int n, m;
 int idx[][], id_clock;
 int arr[][], sum;
 int di[] = { , , +, - };
 int dj[] = { +, -, ,  };
 Dinic D;

 int main() {
     while( scanf( "%d", &n )== ) {
         id_clock = ;
         sum = ;
         for( int i=; i<=n; i++ )
             for( int j=; j<=n; j++ ) {
                 scanf( "%d", &arr[i][j] );
                 sum += arr[i][j];
                 idx[i][j] = ++id_clock;
             }
         D.init( id_clock+, id_clock+, id_clock+ );
         for( int i=; i<=n; i++ )
             for( int j=; j<=n; j++ ) {
                 if( (i+j)& ) {
                     D.add_edge( D.src, idx[i][j], arr[i][j] );
                     for( int d=; d<; d++ ) {
                         int ni = i+di[d];
                         int nj = j+dj[d];
                         if( <=ni&&ni<=n && <=nj&&nj<=n ) {
                             int u = idx[i][j];
                             int v = idx[ni][nj];
                             D.add_edge( u, v, oo );
                         }
                     }
                 } else {
                     D.add_edge( idx[i][j], D.dst, arr[i][j] );
                 }
             }
         printf( "%d\n", sum-D.maxflow() );
     }
 }