[BZOJ 1475] 方格取数

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=1475

[算法]

首先将方格黑白染色 ， 也就是说 ， 如果(i + j)为奇数 ， 这个点就是黑点 ， 否则是白点

那么这个n * n的方格就被分为了两个集合 ， 一个是黑点集合 ， 一个是白点集合

如果选取一个黑点 ， 造成影响的是四方向内的白点

如果选取一个白点 ， 造成影响的是四方向内的黑点

考虑首先选取所有的点 ， 然后去掉最小代价的点 ， 并使方案合法

那么这就是一个最小割的经典模型 ：

将源点向所有黑点连流量为权值的边

将所有白点向汇点连流量为权值的边

将所有黑点向四方向内的白点连流量为正无穷的边

求解这个图的最小割即可

时间复杂度 ： O(dinic(N , M))

[代码]

#include<bits/stdc++.h>
using namespace std;
#define N 110
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int inf = 1e9;
const int dx[] = { ,  , - , };
const int dy[] = {- ,  ,  , };

struct edge
{
    int to , w , nxt;
} e[N * N * ];

int n , m , S , T , tot;
int a[N][N];
int dep[N * N] , head[N * N];

template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }
template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void read(T &x)
{
   T f = ; x = ;
   char c = getchar();
   for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
   for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
   x *= f;
}
inline bool bfs(int s)
{
    queue< int > q;
    q.push(s);
    memset(dep ,  , sizeof(dep));
    dep[s] = ;
    while (!q.empty())
    {
        int cur = q.front();
        q.pop();
        for (int i = head[cur]; i; i = e[i].nxt)
        {
            int v = e[i].to , w = e[i].w;
            if (w >  && dep[v] == -)
            {
                dep[v] = dep[cur] + ;
                q.push(v);
                if (v == T) return true;
            }
        }
    }
    return false;
}
inline int dinic(int u , int flow)
{
    int rest = flow;
    if (u == T)
        return flow;
    for (int i = head[u]; i && rest; i = e[i].nxt)
    {
        int v = e[i].to , w = e[i].w;
        if (dep[v] == dep[u] +  && w > )
        {
            int k = dinic(v , min(w , rest));
            if (!k) dep[v] = ;
            rest -= k;
            e[i].w -= k;
            e[i ^ ].w += k;
        }
    }
    return flow - rest;
}
inline void addedge(int u , int v , int w)
{
    ++tot;
    e[tot] = (edge){v , w , head[u]};
    head[u] = tot;
    ++tot;
    e[tot] = (edge){u ,  , head[v]};
    head[v] = tot;
}
inline bool valid(int x , int y)
{
    return x >=  && x <= m && y >=  && y <= n;
}

int main()
{

    read(m); n = m;
    int cnt = ;
    for (int i = ; i <= m; i++)
    {
        for (int j = ; j <= n; j++)
        {
            read(a[i][j]);
            cnt += a[i][j];
        }
    }
    S = n * m +  , T = S + ;
    tot = ;
    for (int i = ; i <= m; i++)
    {
        for (int j = ; j <= n; j++)
        {
            if ((i + j) & )
                addedge(S , (i - ) * n + j , a[i][j]);
            else addedge((i - ) * n + j , T , a[i][j]);
        }
    }
    for (int i = ; i <= m; i++)
    {
        for (int j = ; j <= n; j++)
        {
            for (int k = ; k < ; k++)
            {
                int x = i + dx[k] , y = j + dy[k];
                if (valid(x , y) && (i + j) & )
                    addedge((i - ) * n + j , (x - ) * n + y , inf);
            }
        }
    }
    int ans = ;
    while (bfs(S))
    {
        while (int flow = dinic(S , inf)) ans += flow;
    }
    printf("%d\n" , cnt - ans);

    return ;
}