[Luogu P2825] [BZOJ 4554] [HEOI2016 TJOI2016]游戏

洛谷传送门

BZOJ传送门

题目描述

在2016年，佳缘姐姐喜欢上了一款游戏，叫做泡泡堂。简单的说，这个游戏就是在一张地图上放上若干个炸弹，看是否能炸到对手，或者躲开对手的炸弹。在玩游戏的过程中，小H想到了这样一个问题：当给定一张地图，在这张地图上最多能放上多少个炸弹能使得任意两个炸弹之间不会互相炸到。炸弹能炸到的范围是该炸弹所在的一行和一列，炸弹的威力可以穿透软石头，但是不能穿透硬石头。给定一张$n*m$的网格地图:其中$*$代表空地，炸弹的威力可以穿透，可以在空地上放置一枚炸弹。$x$代表软石头，炸弹的威力可以穿透，不能在此放置炸弹。#代表硬石头，炸弹的威力是不能穿透的，不能在此放置炸弹。例如：给出$1*4$的网格地图*xx*，这个地图上最多只能放置一个炸弹。给出另一个$1*4$的网格地图*x#*，这个地图最多能放置两个炸弹。现在小H任意给出一张$n*m$的网格地图，问你最多能放置多少炸弹。

输入输出格式

输入格式：

第一行输入两个正整数$n,m,n$表示地图的行数，$m$表示地图的列数。$1≤n,m≤50$。接下来输入$n$行$m$列个字符，代表网格地图。$*$的个数不超过$n*m$个。

输出格式：

输出一个整数$a$，表示最多能放置炸弹的个数

输入输出样例

输入样例#1：

4 4
#∗∗∗
∗#∗∗
∗∗#∗
xxx#

输出样例#1：

5

解题分析

看看数据范围， 嗯这很网络流。

然后仔细想一下， 的确是网络流…

一个格子会造成一个横行和竖行不能放其他炸弹， 那么我们提取出所有横行， 并从源点向其连流量为$1$边； 再从横行向对应竖行连边， 最后从竖行向汇点连流量为 1 1 <script type="math/tex" id="MathJax-Element-16">1</script>的边。

有点像这道题？

代码如下：

#include <cstdio>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <queue>
#define R register
#define IN inline
#define gc getchar()
#define W while
#define S 0
#define T 10004
#define MX 10005
std::queue <int> q;
char mp[55][55];
int n, m, cnt, arr;
int id1[55][55], id2[55][55], head[MX], layer[MX];
struct Edge {int to, fl, nex;} edge[T << 1];
int dir1[2] = {1, 0}, dir2[2] = {0, 1};
IN void add(R int from, R int to, R int fl)
{
    edge[++cnt] = {to, fl, head[from]}, head[from] = cnt;
    edge[++cnt] = {from, 0, head[to]}, head[to] = cnt;
}
void solve(R int x, R int y, int *dir, int (*res)[55])
{
    ++arr;
    W (x <= n && y <= m && mp[x][y] != '#')
    {
        res[x][y] = arr;
        x += dir[0], y += dir[1];
    }
}
IN bool BFS()
{
    std::memset(layer, 0, sizeof(layer));
    q.push(S); layer[S] = 1;
    R int now;
    W (!q.empty())
    {
        now = q.front(); q.pop();
        for (R int i = head[now]; ~i; i = edge[i].nex)
        {
            if(edge[i].fl && !layer[edge[i].to])
            {
                layer[edge[i].to] = layer[now] + 1;
                q.push(edge[i].to);
            }
        }
    }
    return layer[T];
}
int DFS(R int now, R int val)
{
    if(now == T) return val;
    int buf, lef = val;
    for (R int i = head[now]; ~i; i = edge[i].nex)
    {
        if((layer[edge[i].to] != layer[now] + 1) || !edge[i].fl) continue;
        buf = DFS(edge[i].to, std::min(lef, edge[i].fl));
        if(!buf) continue;
        edge[i].fl -= buf, edge[i ^ 1].fl += buf;
        lef -= buf;
        if(lef <= 0) return val;
    }
    return val - lef;
}
int init()
{
    int ret = 0;
    W (BFS())
    ret += DFS(S, MX);
    return ret;
}
int main(void)
{
    scanf("%d%d", &n, &m);
    std::memset(head, cnt = -1, sizeof(head));
    for (R int i = 1; i <= n; ++i) scanf("%s", mp[i] + 1);
    for (R int i = 1; i <= n; ++i)
    for (R int j = 1; j <= m; ++j)
    {
        if(mp[i][j] == '#') continue;
        if(!id1[i][j]) solve(i, j, dir1, id1), add(S, arr, 1);
        if(!id2[i][j]) solve(i, j, dir2, id2), add(arr, T, 1);
        if(mp[i][j] == '*')add(id1[i][j], id2[i][j], 1);
    }
    printf("%d", init());
}