A - Fire Net HDU - 1045（二分图最大匹配）

题意

1. 给定一个二维表格，表格中的某些点有障碍物，可以阻挡子弹穿过，
2. 现在让我们在表格中的空格中放置尽可能多的 炮塔，炮塔可以向四个方向发射子弹，
3. 问我们最多可以放置多少个炮塔，这些炮塔中不能互相攻击。

思路

1. 只有在有障碍物阻隔的情况下，才会出现一行有多个炮台的情况，因此我们可以对每一行没有障碍物阻挡的区域进行缩点并编上一个编号，放到左点集中，
2. 同理对每一列没有障碍物阻挡的取余进行缩点，并依次编上编号，放到右点集中。
   
3. 对左右集合进行二分图最大匹配，答案就是最大的匹配的数量
   
4. 考虑为甚么这样是对的，我的理解是我们把左点集中的元素当成一个表格中的行，把右点集中的元素当成列，因为每行、每列都只能放一个元素，那么一行只能与一个列进行匹配。

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
#include <bitset>
#include <vector>
using namespace std;
void fre() { system("clear"), freopen("A.txt", "r", stdin); freopen("Ans.txt","w",stdout); }
void Fre() { system("clear"), freopen("A.txt", "r", stdin);}
void Run(int x = 0) {     
#ifdef ACM  //宏定义免注释 freopen
    if (! x) fre(); else Fre();
#endif
}
#define ios ios::sync_with_stdio(false)
#define Pi acos(-1)
#define pb push_back
#define fi first
#define se second
#define db double
#define ll long long
#define ull unsigned long long
#define Pir pair<ll, ll>
#define m_p make_pair
#define for_(i, s, e) for(ll i = (ll)(s); i <= (ll)(e); i ++)
#define rep_(i, e, s) for(ll i = (ll)(e); i >= (ll)(s); i --)
#define memset(a, b, c) memset(a, (int)b, c);
#define size() size() * 1LL
#define sc scanf
#define pr printf
#define sd(a) sc("%lld", &a)
#define ss(a) sc("%s", a)
#define __  pr( "------------------------\n" );
#define ___ pr("\n------------------------\n");
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define esp 1e-7
#define mod (ll)(1e9 + 7)
/*=========================ACMer===========================*/
const ll mxn = 20;
char mz[mxn][mxn];
ll a[mxn][mxn], b[mxn][mxn];
ll idx, jdx;
ll G[mxn][mxn];
ll match[mxn];
ll use[mxn];

bool dfs(ll u)
{
    for_(v, 1, jdx)
    {
        if (G[u][v] && ! use[v])
        {
            use[v] = 1;
            if (match[v] == -1 || dfs(match[v]))
            {
                match[v] = u;
                return 1;
            }
        }
    }
    return 0;
}

ll Hungary()
{
    memset(match, -1, sizeof match);
    ll ans = 0;
    for_(i, 1, idx)
    {
        memset(use, 0, sizeof use);
        if (dfs(i)) ans ++;
    }
    return ans;
}

int main()
{
    Run();
    ll n;
    while (sd(n) && n)
    {
        memset(a, 0, sizeof a);
        memset(b, 0, sizeof b);
        memset(G, 0, sizeof G);

        for_(i, 1, n) sc("%s", mz[i] + 1);

        idx = 1;
        for_(i, 1, n)
        {
            ll flag = 0;
            for_(j, 1, n)
            {
                if (mz[i][j] == 'X' && flag)
                {
                    flag = 0;
                    idx ++;
                }
                else if(mz[i][j] == '.')
                {
                    flag = 1;
                    a[i][j] = idx;
                }
            }
            if (flag) idx ++;
        }

        jdx = 1;
        for_(j, 1, n)
        {
            ll flag = 0;
            for_(i, 1, n)
            {
                if (mz[i][j] == 'X' && flag)
                {
                    flag = 0;
                    jdx ++;
                }
                else if(mz[i][j] == '.')
                {
                    flag = 1;
                    b[i][j] = jdx;
                }
            }
            if (flag) jdx ++;
        }

        for_(i, 1, n)
        {
            for_(j, 1, n)
            {
                if (a[i][j] && b[i][j])
                {
                    G[a[i][j]][b[i][j]] = 1;
                }
            }
        }
        pr("%lld\n", Hungary());
    }


    return 0;
}