POJ2226 Muddy Fields 二分匹配 最小顶点覆盖 好题

在一个n*m的草地上，.代表草地，*代表水，现在要用宽度为1，长度不限的木板盖住水，

木板可以重叠，但是所有的草地都不能被木板覆盖。

问至少需要的木板数。

这类题的建图方法：

把矩阵作为一个二分图，以行列分别作为2个顶点集

首先以每一行来看，把这一行里面连续的*编号，作为一个顶点

再以每一列来看，把这一列里面连续的*编号，作为一个顶点

则每一个*都有2个编号，以行看时有一个，以列看时有一个，则把这2个编号连边，容量为1

再建一个源点，连接所有行的编号，一个汇点，连接所有列的编号

这道题要求的是，所有*都被覆盖，即找到一个顶点的集合S，使得任意边都有至少一个顶点属于

S,即求一个点集顶点覆盖S，又要木板数最少，所以求的就是最小顶点覆盖。

最小顶点覆盖怎么求？

二分图中，有：

最小顶点覆盖=最大匹配

所以这道题就转化为求二分图的最大匹配了

再转化为最大流dinic算法。

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>

using namespace std;

const int maxn=2510;
const int inf=0x3f3f3f3f;
const int s=0;
int t;
int tota;
int totb;

inline int min(int x,int y)
{
    return x<y?x:y;
}

struct Edge
{
    int to,cap,rev;
};
vector<Edge>edge[maxn];
int iter[maxn];
int level[maxn];
char str[55][55];
int hash[55][55];

void addedge(int from,int to,int cap)
{
    edge[from].push_back((Edge){to,cap,edge[to].size()});
    edge[to].push_back((Edge){from,0,edge[from].size()-1});
}

void build_graph(int n,int m)
{
    for(int i=0;i<n*m;i++)
        edge[i].clear();
    tota=0;
    for(int i=1;i<=n;i++)
    {
        int j=1;
        while(j<=m)
        {
            if(str[i][j]=='*')
            {
                tota++;
                hash[i][j]=tota;
                while(j<=m&&str[i][j+1]=='*')
                {
                    j++;
                    hash[i][j]=tota;
                }
            }
            j++;
        }
    }
    totb=tota;
    for(int j=1;j<=m;j++)
    {
        int i=1;
        while(i<=n)
        {
            if(str[i][j]=='*')
            {
                totb++;
                addedge(hash[i][j],totb,1);
                while(i<=n&&str[i+1][j]=='*')
                {
                    i++;
                    addedge(hash[i][j],totb,1);
                }
            }
            i++;
        }
    }
    t=tota+totb+1;
    for(int i=1;i<=tota;i++)
        addedge(s,i,1);
    for(int i=tota+1;i<=totb;i++)
        addedge(i,t,1);
}

void bfs()
{
    memset(level,-1,sizeof level);
    queue<int>que;
    while(!que.empty())
        que.pop();
    que.push(s);
    level[s]=1;
    while(!que.empty())
    {
        int u=que.front();
        que.pop();
        for(int i=0;i<edge[u].size();i++)
        {
            Edge &e=edge[u][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[u]+1;
                que.push(e.to);
            }
        }
    }
}

int dfs(int u,int f)
{
    if(u==t)
        return f;
    for(int &i=iter[u];i<edge[u].size();i++)
    {
        Edge &e=edge[u][i];
        if(e.cap>0&&level[e.to]>level[u])
        {
            int d=dfs(e.to,min(f,e.cap));
            if(d>0)
            {
                e.cap-=d;
                edge[e.to][e.rev].cap+=d;
                return d;
            }

        }
    }
    return 0;
}

int solve()
{
    int flow=0;
    while(true)
    {
        bfs();
        if(level[t]<0)
            return flow;
        memset(iter,0,sizeof iter);
        int f;
        while(f=dfs(s,inf))
        {
            flow+=f;
        }
    }
}

int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%s",str[i]+1);
        }
        build_graph(n,m);
        printf("%d
",solve());
    }
    return 0;
}