标签：

Pleasant sheep and big big wolf Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2570    Accepted Submission(s): 1056 Problem Description In ZJNU, there is a well-known prairie. And it attracts pleasant sheep and his companions to have a holiday. Big big wolf and his families know about this, and quietly hid in the big lawn. As ZJNU ACM/ICPC team, we have an obligation to protect pleasant sheep and his companions to free from being disturbed by big big wolf. We decided to build a number of unit fence whose length is 1. Any wolf and sheep can not cross the fence. Of course, one grid can only contain an animal. Now, we ask to place the minimum fences to let pleasant sheep and his Companions to free from being disturbed by big big wolf and his companions.    Input There are many cases.  For every case:  N and M（N,M<=200） then N*M matrix:  0 is empty, and 1 is pleasant sheep and his companions, 2 is big big wolf and his companions.   Output For every case: First line output “Case p:”, p is the p-th case;  The second line is the answer.    Sample Input 4 6 1 0 0 1 0 0 0 1 1 0 0 0 2 0 0 0 0 0 0 2 0 1 1 0   Sample Output Case 1: 4

建图要敢想、敢写。WA的多了，或许就理解的更深。WA两次还是有点收获的。

题意：给你一个N*M的地图，图中只有3个数字，分别为0、1、2。0表示此处是空的，1表示此处有1只羊，2表示此处有一头狼。为了保护羊不被狼吃掉，我们需要修筑篱笆来阻断一些路径。一个篱笆的长度为1，对应图中两个邻近点之间的路径长度。现在问你修筑篱笆的最小长度（或者说是——阻断的点数）。

建图：设置超级源点sink，超级汇点source。

1，sink向所有羊建边，容量为INF，表示不能在此处阻断容量（这里若是一个定值，最小割边集里面可能会有sink到羊的边，这样显然是不对的）。

2，邻近点互相建边，容量为1。表示阻断该边的代价。

3，所有狼向source建边，容量为INF。表示不能在此处阻断流量。

建完图后，若有流量流入汇点则说明有羊会被吃掉，因此我们的目的是用最小的代价来阻断sink->source的所有可行流。这样问题就变成了求解sink->source的最小割。

#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#define MAXN 40000+10
#define MAXM 1000000+10
#define INF 0x3f3f3f3f
using namespace std;
struct Edge
{
    int from, to, cap, flow, next;
};
Edge edge[MAXM];
int head[MAXN], edgenum;
int dist[MAXN];
int cur[MAXN];
bool vis[MAXN];
int N, M;
int sink, source;
void init()
{
    edgenum = 0;
    memset(head, -1, sizeof(head));
}
int point(int x, int y)
{
    return (x-1) * M + y;
}
void addEdge(int u, int v, int w)
{
    Edge E1 = {u, v, w, 0, head[u]};
    edge[edgenum] = E1;
    head[u] = edgenum++;
    Edge E2 = {v, u, 0, 0, head[v]};
    edge[edgenum] = E2;
    head[v] = edgenum++;
}
bool judge(int x, int y)
{
    return x >= 1 && x <= N && y >= 1 && y <= M;
}
void getMap()
{
    int a;
    sink = 0, source = N * M + 1;
    int move[4][2] = {0,1, 0,-1, 1,0, -1,0};
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= M; j++)
        {
            scanf("%d", &a);
            for(int p = 0; p < 4; p++)
            {
                int x = i + move[p][0];
                int y = j + move[p][1];
                if(judge(x, y))
                    addEdge(point(i, j), point(x, y), 1);
            }
            if(a == 1)//羊
                addEdge(sink, point(i, j), INF);//连 超级源点
            else if(a == 2)//狼
                addEdge(point(i, j), source, INF);//连超级汇点
        }
    }
}
bool BFS(int s, int t)
{
    queue<int> Q;
    memset(dist, -1, sizeof(dist));
    memset(vis, false, sizeof(vis));
    dist[s] = 0;
    vis[s] = true;
    Q.push(s);
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        for(int i = head[u]; i != -1; i = edge[i].next)
        {
            Edge E = edge[i];
            if(!vis[E.to] && E.cap > E.flow)
            {
                dist[E.to] = dist[u] + 1;
                if(E.to == t) return true;
                vis[E.to] = true;
                Q.push(E.to);
            }
        }
    }
    return false;
}
int DFS(int x, int a, int t)
{
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int &i = cur[x]; i != -1; i = edge[i].next)
    {
        Edge &E = edge[i];
        if(dist[E.to] == dist[x] + 1 && (f = DFS(E.to, min(a, E.cap-E.flow), t)) > 0)
        {
            edge[i].flow += f;
            edge[i^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }
    return flow;
}
int Maxflow(int s, int t)
{
    int flow = 0;
    while(BFS(s, t))
    {
        memcpy(cur, head, sizeof(head));
        flow += DFS(s, INF, t);
    }
    return flow;
}
int main()
{
    int k = 1;
    while(scanf("%d%d", &N, &M) != EOF)
    {
        init();
        getMap();
        printf("Case %d:\n%d\n", k++, Maxflow(sink, source));
    }
    return 0;
}

hdoj 3046 Pleasant sheep and big big wolf 【最小割】

标签：

原文地址：http://blog.csdn.net/chenzhenyu123456/article/details/48022729