HDU 3046 Pleasant sheep and big wolf（最小割最大流+Dinic）

http://acm.hdu.edu.cn/showproblem.php?pid=3046

题意：

给出矩阵地图和羊和狼的位置，求至少需要建多少栅栏，使得狼不能到达羊。

思路：
狼和羊不能到达，最小割最大流问题。

因为狼和羊都有多只，所以我们加一个超级源点和一个超级汇点，将每只狼与超级源点相连，容量为INF，将每只羊与超级汇点相连，容量为INF。对于地图上的点，每个点都与它上下左右相连，容量设为1。

接下来，我们只需要计算出从超级源点到超级汇点的最大流，因为最小割等于最大流。

#include<iostream> 
#include<algorithm>
#include<cstring>
#include<string>
#include<vector>
#include<queue>
using namespace std;

const int maxn = 210*210;
const int INF = 0x3f3f3f3f;

struct Edge
{
    int from,to, cap, flow;
    Edge(int u, int v, int c, int f) :from(u), to(v), cap(c), flow(f){}
};

int n, m,t;
vector<Edge> edges;
vector<int> G[maxn];
int vis[maxn];
int d[maxn];   //从起点到i的距离
int cur[maxn]; //当前弧下标
int flow;

void init()
{
    for (int i = 0; i < maxn; i++)
        G[i].clear();
    edges.clear();
}

void AddEdge(int from, int to, int cap)
{
    edges.push_back(Edge(from, to, cap, 0));
    edges.push_back(Edge(to, from, 0, 0));
    int m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
}


int BFS()
{
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(0);
    d[0] = 0;
    vis[0] = 1;
    while (!Q.empty())
    {
        int x = Q.front();
        Q.pop();
        for (int i = 0; i < G[x].size(); i++)
        {
            Edge& e = edges[G[x][i]];
            if (!vis[e.to] && e.cap>e.flow)
            {
                vis[e.to] = 1;
                d[e.to] = d[x] + 1;
                Q.push(e.to);
            }
        }
    }
    return vis[n*m + 1];
}

int DFS(int x,int a)
{
    if (x == n*m + 1 || a == 0)  return a;
    int flow = 0, f;
    for (int& i = cur[x]; i < G[x].size(); i++)
    {
        Edge& e = edges[G[x][i]];
        if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow)))>0)
        {
            e.flow += f;
            edges[G[x][i] ^ 1].flow -= f;
            flow += f;
            a -= f;
            if (a == 0)  break;
        }
    }
    return flow;
}

void Maxflow(int s,int t)
{
    flow = 0;
    while (BFS())
    {
        memset(cur, 0, sizeof(cur));
        flow += DFS(s, INF);
    }
}

int main()
{
    //freopen("D:\txt.txt", "r", stdin);
    int kase = 0;
    int a;
    while (~scanf("%d%d", &n, &m))
    {
        init();
        for (int i = 1; i <= n;i++)
        for (int j = 1; j <= m; j++)
        {
            if (i != 1)
                AddEdge((i - 1)*m + j, (i-2)*m+j, 1);
            if (i != n)
                AddEdge((i - 1)*m + j, i*m + j, 1);
            if (j != 1)
                AddEdge((i - 1)*m + j, (i - 1)*m + j - 1, 1);
            if (j != m)
                AddEdge((i - 1)*m + j, (i - 1)*m + j + 1, 1);
            scanf("%d", &a);
            if (a == 1)
                AddEdge(0, (i - 1)*m + j, INF);
            else if (a == 2)
                AddEdge((i - 1)*m + j, m*n + 1, INF);
        }
        Maxflow(0, n*m + 1);
        printf("Case %d:
%d
", ++kase, flow);
    }
}