HDU 1569 二分图带权最大独立集 最小割

题意：给你一个n×m的棋盘 每个格子都有一个非负整数 从中选取一些数 使得相邻两数没有公共边 问取到的数的最大和是多少

思路：取出来的数不相邻 也就是说如果选取一个数 它上下左右都不能选 而且和要最大 这是不是像某种图论模型 没错 是他是他就是他 二分图最大独立集～ 但是这个题目多了权值 就不能用Hungary算法来实现了 要用到网络流的知识了 具体做法是 对于奇数格子的点 将源点与该格子连边 容量为格子的值 偶数格子的点 将该点与汇点连边 对于不可以同时选的点i j 连边i 到 j 容量为INF 格子总权值-最大流即为答案

为什么这么做是正确的呢 对于不带权的二分图 最大独立集 = 顶点数 - 最大匹配数 而对于带权的二分图 求完最大流以后的最小割边即为匹配的边 因为最小割是容量最小的割 所以求出来的匹配的边的权值是所有可能的匹配情况的最小值 答案即为最大了～

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define REP( i, a, b ) for( int i = a; i < b; i++ )
#define FOR( i, a, b ) for( int i = a; i <= b; i++ )
#define CLR( a, x ) memset( a, x, sizeof a )
#define CPY( a, x ) memcpy( a, x, sizeof a )
#define BUG puts( "**** BUG ****" )

typedef long long LL;

const int maxn = 2500 + 10;
const int maxe = 10000 + 10;
const int INF = 0x7fffffff;
const int dir[4][2] = {-1, 0, 1, 0, 0, -1, 0, 1};

struct Edge{
int v, c, f;
int next;
Edge() {}
Edge(int v, int c, int f, int next) : v(v), c(c), f(f), next(next) {}
};

struct ISAP{
int n, s, t;
int num[maxn], cur[maxn], d[maxn], p[maxn];
int Head[maxn], cntE;
int Q[maxn], head, tail;
Edge edge[maxe];
void Init(int n){
this -> n = n;
cntE = 0;
CLR(Head, -1);
}
void Add(int u, int v, int c){
edge[cntE] = Edge(v, c, 0, Head[u]);
Head[u] = cntE++;
edge[cntE] = Edge(u, 0, 0, Head[v]);
Head[v] = cntE++;
}
void Bfs(){
CLR(d, -1);
CLR(num, 0);
d[t] = 0;
head = tail = 0;
Q[tail++] = t;
num[0] = 1;
while(head != tail){
int u = Q[head++];
for(int i = Head[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(~d[e.v]) continue;
d[e.v] = d[u] + 1;
Q[tail++] = e.v;
num[d[e.v]] ++;
}
}
}
LL Maxflow(int s, int t){
this -> s = s;
this -> t = t;
CPY(cur, Head);
Bfs();
int u = p[s] = s;
LL flow = 0;
while(d[s] < n){
if(u == t){
int f = INF, neck;
for(int i = s; i != t; i = edge[cur[i]].v){
if(f > edge[cur[i]].c - edge[cur[i]].f){
f = edge[cur[i]].c - edge[cur[i]].f;
neck = i;
}
}
for(int i = s; i != t; i = edge[cur[i]].v){
edge[cur[i]].f += f;
edge[cur[i]^1].f -= f;
}
flow += (LL)f;
u = neck;
}
int ok = 0;
for(int i = cur[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(e.c > e.f && d[e.v] + 1 == d[u]){
ok = 1;
cur[u] = i;
p[e.v] = u;
u = e.v;
break;
}
}
if(!ok){
int m = n - 1;
if(--num[d[u]] == 0) break;
for(int i = Head[u]; ~i; i = edge[i].next){
Edge &e = edge[i];
if(e.c - e.f > 0 && m > d[e.v]){
cur[u] = i;
m = d[e.v];
}
}
++num[d[u] = m + 1];
u = p[u];
}
}
return flow;
}

}solver;

int n, m, sum;
int map[60][60];

bool Judge(int x, int y){
if(x >= 1 && x <= n && y >= 1 && y <= m)
return true;
return false;
}

void input(){ sum = 0; FOR(i, 1, n) FOR(j, 1, m) scanf("%d", &map[i][j]), sum += map[i][j]; }

void solve(){
int S = 0, T = n * m + 1;
solver.Init(n * m + 2);
FOR(i, 1, n) FOR(j, 1, m)
if((i + j) & 1){
solver.Add(S, (i - 1) * m + j, map[i][j]);
REP(k, 0, 4){
int dx = i + dir[k][0];
int dy = j + dir[k][1];
if(Judge(dx, dy)) solver.Add((i - 1) * m + j, (dx - 1) * m + dy, INF);
}
}
else solver.Add((i - 1) * m + j, T, map[i][j]);
printf("%d\n", sum - solver.Maxflow(S, T));
}

int main()
{
//freopen("in.txt", "r", stdin);
while(~scanf("%d%d", &n, &m)){
input();
solve();
}
return 0;
}