HDOJ 4621: Life Game

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

题目大意：

有一个n*m的网格，可以把它染成黑色或白色。

如果某个格子被染成黑色，它可以获得一定的权值b[i]，如果某个格子被染成白色，它也可以获得一定的权值w[i]。

另有若干要求，要求的形式是，指定一种颜色，如果某子矩阵都被染成这种颜色，则可以获得一定的额外奖励。

求最大获益。

算法：

这题的建模非常简单。

对于每个点，向S连一条边，容量是权值b[i]，向T连一条边，容量是权值w[i]。

若S到这个点的边不属于最小割（未满流），代表这个点被染成了黑色。
对于每个要求，以要求某个子矩阵都被染成白色为例。

那么由子矩阵中的每个点向这个要求所代表的点连一条权值为INF的边，再由这个点连一条边到T，容量是满足这个要求所能带来的奖励。

如果由子矩阵中的点连向这个要求的边不在最小割中，说明子矩阵中的某个点被染成了黑色，这个要求没有被满足，它连着T的边必须在最小割中（否则形成增广路）。

最后用所有的权值的总和减去最大流，也就是不在最小割中的边的权值和，即为答案。

但是，这题的边非常多，会导致MLE。

所以要用二维RMQ优化。

这样可以使得每个要求最多向4个矩阵连边就可以了。

学会二维RMQ之后做这题就很简单了。

代码如下：

#include<cstdio>
#include<iostream>
#include<sstream>
#include<cstdlib>
#include<cstring>
#include<string>
#include<climits>
#include<cmath>
#include<algorithm>
#include<queue>
#include<vector>
#include<stack>
#include<set>
#include<map>
#define INF 0x3f3f3f3f
#define eps 1e-8
using namespace std;


const int MAXN = 1100000;
const int MAXM = 2100000;


int Q[MAXN], dep[MAXN], head[MAXN], cur[MAXN];
int to[MAXM], cap[MAXM], nxt[MAXM];
int b[100][100], w[100][100];
int E;
int n, m, qnum;
int maxd1, maxd2;


int log_2(int x)
{
    int ans = 0;
    while ((1 << ans) <= x)
    {
        ans ++;
    }
    return ans - 1;
}


int get_id(int flg, int i, int j = 0, int k1 = 0, int k2 = 0)
{
    if(flg == 0)
    {
        return i * m + j + 2;
    }
    else if (flg < 3)
    {
        return n * m
               + n * m * maxd1 * maxd2 * (flg - 1)
               +(i * m + j) * maxd1 * maxd2 
               + k1 * maxd2 + k2 + 2;
    }
    else
    {
        return n * m + n * m * maxd1 * maxd2 + i + 2;
    }
}


void _addedge(int u, int v, int w)
{
    to[E] = v;
    cap[E] = w;
    nxt[E] = head[u];
    head[u] = E ++;
}


void addedge(int u, int v, int w)
{
    _addedge(u, v, w);
    _addedge(v, u, 0);
}


bool bfs(int S, int T)
{
    memset(dep, -1, sizeof(dep));
    dep[T] = 0;
    int front = 0, rear = 0;
    Q[rear ++] = T;
    while (front != rear && dep[S] == -1)
    {
        int u = Q[front ++];
        for (int i =head[u]; i != -1; i = nxt[i])
        {
            int v = to[i];
            if (cap[i ^ 1] && dep[v] == -1)
            {
                dep[v] = dep[u] + 1;
                Q[rear ++] = v;
            }
        }
    }
    return dep[S] != -1;
}


int dfs(int S, int T, int lim)
{
    if (S == T)
    {
        return lim;
    }
    int tmp = lim;
    for (int& i = cur[S]; i != -1; i = nxt[i])
    {
        int v = to[i];
        if (cap[i] && dep[S] == dep[v] + 1)
        {
            int ret = dfs(v, T, min(tmp, cap[i]));
            tmp -= ret;
            cap[i] -= ret;
            cap[i ^ 1] += ret;
        }
        if (! tmp)
        {
            break;
        }
    }
    return lim - tmp;
}


int dinic(int S, int T, int n)
{
    int ans = 0;
    while (bfs(S, T))
    {
        for (int i = 0; i < n; i ++)
        {
            cur[i] = head[i];
        }
        ans += dfs(S, T, INT_MAX);
    }
    return ans;
}


void init()
{
    E=0;
    memset(head, -1, sizeof(head));
}


int main()
{
    int cas;
    scanf("%d", &cas);
    while (cas --)
    {
        int ans = 0;
        int S = 0, T = 1;
        scanf("%d %d %d", &n, &m, &qnum);
        init();
        maxd1 = log_2(n) + 1;
        maxd2 = log_2(m) + 1;
        for (int i = 0; i < n; i ++)
        {
            for (int j = 0; j < m; j ++)
            {
                scanf("%d", &b[i][j]);
                ans += b[i][j];
                addedge(S, get_id(0, i, j), b[i][j]);
                addedge(get_id(0, i, j),
                        get_id(1, i, j, 0, 0),
                        INF);
            }
        }
        for (int i = 0; i < n; i ++)
        {
            for (int j = 0; j < m; j ++)
            {
                scanf("%d", &w[i][j]);
                ans += w[i][j];
                addedge(get_id(0, i, j), T, w[i][j]);
                addedge(get_id(2, i, j, 0, 0),
                        get_id(0, i, j),
                        INF);
            }
        }
        for (int i = 0; i < n; i ++)
        {
            for (int j = 0; j <m; j ++)
            {
                for (int k1 = 0; i + (1 << k1) <= n; k1 ++)
                {
                    for (int k2 = 0; j + (1 << k2) <= m; k2 ++)
                    {
                        if (k1)
                        {
                            addedge(get_id(1, i, j, k1 - 1, k2),
                                    get_id(1, i, j, k1, k2),
                                    INF);
                            addedge(get_id(1, i + (1 << k1 - 1), j, k1 - 1, k2),
                                    get_id(1, i, j, k1, k2),
                                    INF);
                            addedge(get_id(2, i, j, k1, k2),
                                    get_id(2, i, j, k1 - 1, k2),
                                    INF);
                            addedge(get_id(2, i, j, k1, k2),
                                    get_id(2, i + (1 << k1 - 1), j, k1 - 1, k2),
                                    INF);
                        }
                        else if (k2)
                        {
                            addedge(get_id(1, i, j, k1, k2 - 1),
                                    get_id(1, i, j, k1, k2),
                                    INF);
                            addedge(get_id(1, i, j + (1 << k2 - 1), k1, k2 - 1),
                                    get_id(1, i, j, k1, k2),
                                    INF);
                            addedge(get_id(2, i, j, k1, k2),
                                    get_id(2, i, j , k1, k2 - 1),
                                    INF);
                            addedge(get_id(2, i, j, k1, k2),
                                    get_id(2, i, j + (1 << k2 - 1), k1, k2 - 1),
                                    INF);
                        }
                    }
                }
            }
        }
        for (int i = 0; i < qnum; i++)
        {
            int r1, c1, r2, c2;
            int flg, val;
            scanf("%d %d %d %d %d %d", &r1, &c1, &r2, &c2, &flg, &val);
            r1 --;
            r2 --;
            c1 --;
            c2 --;
            ans += val;
            int k1 = log_2(r2 - r1 + 1);
            int k2 = log_2(c2 - c1 + 1);
            if(!flg)
            {
                addedge(get_id(3, i), T, val);
                addedge(get_id(1, r1, c1, k1, k2), get_id(3, i), INF);
                addedge(get_id(1, r2 - (1 << k1) + 1, c1, k1, k2), get_id(3, i), INF);
                addedge(get_id(1, r1, c2 - (1 << k2) + 1, k1, k2), get_id(3, i), INF);
                addedge(get_id(1, r2 - (1 << k1) + 1, c2 - (1 << k2) + 1, k1, k2), get_id(3, i), INF);
            }
            else
            {
                addedge(S, get_id(3, i), val);
                addedge(get_id(3, i), get_id(2, r1, c1, k1, k2), INF);
                addedge(get_id(3, i), get_id(2, r2 - (1 << k1) + 1, c1, k1, k2), INF);
                addedge(get_id(3, i), get_id(2, r1, c2 - (1 << k2) + 1, k1, k2), INF);
                addedge(get_id(3, i), get_id(2, r2 - (1 << k1) + 1, c2 - (1 << k2) + 1, k1, k2), INF);
            }
        }
        printf("%d\n", ans - dinic(S, T , n * m + 2 * (n * m * maxd1 * maxd2) + qnum + 2));
    }
    return 0;
}