HDU 1569 - 方格取数(2) - [最大点权独立集与最小点权覆盖集]

嗯，这是关于最大点权独立集与最小点权覆盖集的姿势，很简单对吧，然后开始看题。

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1569

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Problem Description

给你一个m*n的格子的棋盘，每个格子里面有一个非负数。
从中取出若干个数，使得任意的两个数所在的格子没有公共边，就是说所取数所在的2个格子不能相邻，并且取出的数的和最大。

Input

包括多个测试实例，每个测试实例包括2整数m,n和m*n个非负数(m<=50,n<=50)

Output

对于每个测试实例，输出可能取得的最大的和

Sample Input

3 3

75 15 21

75 15 28

34 70 5

Sample Output

188

题目思路：

首先我们把所有相邻的格子都连一条边，那么我们的问题就转化成：

这张图上，我们要取得最大的点权（这里的点就相当于带权的格子）集，并且这个点集里的任意两个点之间都没有边（即任意两点不相邻）。

这个即最大点权独立集问题，根据上面的讲解，转化成最小点权覆盖集进行求解。

于是依样画葫芦，先求出所有点权和，记为sum(Wv)；

每个相邻的两个格子建边，cap设为INF，方向为从(i+j)是奇数的点到(i+j)是偶数的点；

建立超级源点s，连到所有(i+j)为奇数的点，方向为s出发，cap设为点权；

建立超级汇点t，连到所有(i+j)为偶数的点，方向为到达t，cap设为点权；

这样的话，这个图中，m行n列的方格阵，|V| = mn+2，|E| = m(n－1)＋n(m－1) = 2mn－m－n；

我们做最大流求s-t最小割cut.w，便可以得到答案为sum(Wv) - cut.w。

 #include<cstdio>
 #include<cstring>
 #include<vector>
 #include<queue>
 #define MAX 53*53
 #define INF 0x3f3f3f3f
 using namespace std;
 int m,n,map[][],sum;
 int d[][]={{,+},{+,},{,-},{-,}};
 struct Edge{
     int u,v,c,f;
 };
 struct Dinic
 {
     int s,t;
     vector<Edge> E;
     vector<int> G[MAX];
     bool vis[MAX];
     int lev[MAX];
     int cur[MAX];
     void init(int l,int r)
     {
         E.clear();
         for(int i=l;i<=r;i++) G[i].clear();
     }
     void addedge(int from,int to,int cap)
     {
         E.push_back((Edge){from,to,cap,});
         E.push_back((Edge){to,from,,});
         G[from].push_back(E.size()-);
         G[to].push_back(E.size()-);
     }
     bool bfs()
     {
         memset(vis,,sizeof(vis));
         queue<int> q;
         q.push(s);
         lev[s]=;
         vis[s]=;
         while(!q.empty())
         {
             int now=q.front(); q.pop();
             for(int i=,_size=G[now].size();i<_size;i++)
             {
                 Edge edge=E[G[now][i]];
                 int nex=edge.v;
                 if(!vis[nex] && edge.c>edge.f)
                 {
                     lev[nex]=lev[now]+;
                     q.push(nex);
                     vis[nex]=;
                 }
             }
         }
         return vis[t];
     }
     int dfs(int now,int aug)
     {
         if(now==t || aug==) return aug;
         int flow=,f;
         for(int& i=cur[now],_size=G[now].size();i<_size;i++)
         {
             Edge& edge=E[G[now][i]];
             int nex=edge.v;
             if(lev[now]+ == lev[nex] && (f=dfs(nex,min(aug,edge.c-edge.f)))>)
             {
                 edge.f+=f;
                 E[G[now][i]^].f-=f;
                 flow+=f;
                 aug-=f;
                 if(!aug) break;
             }
         }
         return flow;
     }
     int maxflow()
     {
         int flow=;
         while(bfs())
         {
             memset(cur,,sizeof(cur));
             flow+=dfs(s,INF);
         }
         return flow;
     }
 }dinic;
 int inmap(int i,int j)
 {
     if(<=i && i<=m && <=j && j<=n) return (i-)*n+j;
     else return ;
 }
 int main()
 {
     while(scanf("%d%d",&m,&n)!=EOF)//m行n列
     {
         dinic.init(,m*n+);
         sum=;
         dinic.s=, dinic.t=m*n+;
         for(int i=;i<=m;i++)
         {
             for(int j=;j<=n;j++)
             {
                 scanf("%d",&map[i][j]);
                 sum+=map[i][j];
                 int id=(i-)*n+j;
                 if((i+j)%)
                 {
                     for(int k=,_id;k<;k++) if(_id=inmap(i+d[k][],j+d[k][])) dinic.addedge(id,_id,INF);
                     dinic.addedge(dinic.s,id,map[i][j]);
                 }
                 else dinic.addedge(id,dinic.t,map[i][j]);
             }
         }
         printf("%d\n",sum-dinic.maxflow());
     }
 }