hoj2713（最小点权覆盖）

经典的最大点权独立集问题。转化为最小点权覆盖集：先将网格黑白染色，从源
点到每个黑点有一条边，从每个白点到汇点有一条边，容量均为相应宝石的价值。
每个黑点向与其相邻的四个白点连边，容量为∞。设最小割为 ans，结果即为∑

Cij – ans

#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
typedef int cap_type;
#define MAX_V 50*50 + 30 + 16
struct edge
{
	int to, rev;
	cap_type cap;

	edge(int to, cap_type cap, int rev) : to(to), cap(cap), rev(rev)
	{}
};

vector <edge> G[MAX_V];
int level[MAX_V];
int iter[MAX_V];
void add_edge(int from, int to, int cap)
{
	G[from].push_back(edge(to, cap, G[to].size()));
	G[to].push_back(edge(from, 0, G[from].size() - 1));
}
void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0;
	que.push(s);
	while (!que.empty())
	{
		int v = que.front();
		que.pop();
		for (int i = 0; i < G[v].size(); ++i)
		{
			edge &e = G[v][i];
			if (e.cap > 0 && level[e.to] < 0)
			{
				level[e.to] = level[v] + 1;
				que.push(e.to);
			}
		}
	}
}
cap_type dfs(int v, int t, cap_type f)
{
	if (v == t)
	{
		return f;
	}
	for (int &i = iter[v]; i < G[v].size(); ++i)
	{
		edge &e = G[v][i];
		if (e.cap > 0 && level[v] < level[e.to])
		{
			cap_type d = dfs(e.to, t, min(f, e.cap));
			if (d > 0)
			{
				e.cap -= d;
				G[e.to][e.rev].cap += d;
				return d;
			}
		}
	}

	return 0;
}
cap_type max_flow(int s, int t)
{
	cap_type flow = 0;
	for (;;)
	{
		bfs(s);
		if (level[t] < 0)
		{
			return flow;
		}
		memset(iter, 0, sizeof(iter));
		cap_type f;
		while ((f = dfs(s, t, 0x3f3f3f3f)) > 0)
		{
			flow += f;
		}
	}
}
int cases,n,m;
int w[55][55];
int dir[4][2] = {1,0,-1,0,0,1,0,-1};
int clo[55][55];
typedef pair<int,int> P;
void paint()
{
    queue<P>q; clo[1][1] = 1;
    q.push(make_pair(1,1));
    while(!q.empty())
    {
        P fr = q.front(); q.pop();
        int x = fr.first; int y = fr.second;
        for(int i=0;i<4;i++)
        {
            int nx = x+dir[i][0];
            int ny = y+dir[i][1];
            if(nx<1||nx>n||ny<1||ny>m||clo[nx][ny]!=-1) continue;
            clo[nx][ny] = clo[x][y] ^ 1;
            q.push(make_pair(nx,ny));
        }
    }
}
int main()
{
    scanf("%d",&cases);
    while(cases--)
    {
        scanf("%d%d",&n,&m); int tot = 0;
        for(int i=0;i<=n*m+10;i++) G[i].clear();
        for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) scanf("%d",&w[i][j]),tot+=w[i][j];
        memset(clo,-1,sizeof(clo)); int s = 0; int t = n*m+1; paint();
        for(int i=0;i<n;i++)
            for(int j=1;j<=m;j++)
                if(clo[i+1][j]==1) add_edge(s,i*m+j,w[i+1][j]);
                else add_edge(i*m+j,t,w[i+1][j]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                if(clo[i][j]==1)
                    for(int k=0;k<4;k++)
                    {
                        int nx = i+dir[k][0];
                        int ny = j+dir[k][1];
                        if(nx<1||nx>n||ny<1||ny>m) continue;
                        add_edge((i-1)*m+j,(nx-1)*m+ny,0x3f3f3f3f);
                    }
        int ans = max_flow(s,t);
        printf("%d\n",tot-ans);
    }
    return 0;
}