I - Control - HDU 4289 （最大流）

题意：有N个城市，现在城市S出现了一伙歹徒，他们想运送一些炸弹到D城市，不过警方已经得到了线报知道他们的事情，不过警察不知道他们所在的具体位置，所以只能采取封锁城市的办法来阻断暴徒，不过封锁城市是需要花费一定代价的，由于警局资金比较紧张，所以想知道如果完全阻断暴徒从S城市到达D城市的最小需要花费的代价。

 

输入：

首先输入的是N，M表示有N个城市M条道路，接下来有N行每行一个数字表示封锁这个城市的代价，然后M行道路，每个道路都连接两个城市（路没有交叉，并且是双向路）。

 

分析：这应该叫做最小割，有向图的最小割等于最大流，所以我们只需要把这个图变成有向图就可以直接用最大流的方式做了，因为给的是每个城市的封锁花费，所以需要把每个城市都进行拆点处理，连接边的时候也需要从拆点连接未拆点（为了让路线经过城市）。

下面是AC代码。

 

==========================================================================================================

#include<stdio.h>
#include<algorithm>
#include<queue>
#include< string.h>
using  namespace std;

const  int MAXN =  505;
const  int oo = 1e8+ 7;

struct Edge{ int v, flow, next;}edge[MAXN*MAXN];
int Head[MAXN], cnt;
int layer[MAXN]; /// 分层

void InIt()
{
    cnt =  0;
    memset(Head, - 1,  sizeof(Head));
}
void AddEdge( int u,  int v,  int flow)
{
    edge[cnt].v = v;
    edge[cnt].flow = flow;
    edge[cnt].next = Head[u];
    Head[u] = cnt++;

    swap(u, v);

    edge[cnt].v = v;
    edge[cnt].flow =  0;
    edge[cnt].next = Head[u];
    Head[u] = cnt++;
}
bool bfs( int start,  int End)
{
    queue< int> Q;Q.push(start);
    memset(layer,  0,  sizeof(layer));
    layer[start] =  1;

     while(Q.size())
    {
         int u = Q.front();Q.pop();

         if(u == End) return  true;

         for( int j=Head[u]; j!=- 1; j=edge[j].next)
        {
             int v = edge[j].v;

             if(layer[v] ==  false && edge[j].flow)
            {
                layer[v] = layer[u] +  1;
                Q.push(v);
            }
        }
    }

     return  false;
}
int dfs( int u,  int MaxFlow,  int End)
{
     if(u == End) return MaxFlow;

     int uflow =  0;

     for( int j=Head[u]; j!=- 1; j=edge[j].next)
    {
         int v = edge[j].v;

         if(layer[v]==layer[u]+ 1 && edge[j].flow)
        {
             int flow = min(MaxFlow-uflow, edge[j].flow);
            flow = dfs(v, flow, End);

            edge[j].flow -= flow;
            edge[j^ 1].flow += flow;
            uflow += flow;

             if(uflow == MaxFlow) break;
        }
    }

     if(uflow ==  0)
        layer[u] =  0;
     return uflow;
}
int dinic( int start,  int End)
{
     int MaxFlow =  0;

     while(bfs(start, End) ==  true)
        MaxFlow += dfs(start, oo, End);

     return MaxFlow;
}

int main()
{
     int N, M;

     while(scanf( " %d%d ", &N, &M) != EOF)
    {
         int i, u, v, cost, start, End;

        InIt();

        scanf( " %d%d ", &start, &End);

         for(i= 1; i<=N; i++)
        {
            scanf( " %d ", &cost);
            AddEdge(i, i+N, cost);
        }

         while(M--)
        {
            scanf( " %d%d ", &u, &v);
            AddEdge(u+N, v, oo);
            AddEdge(v+N, u, oo);
        }

        printf( " %d\n ", dinic(start, End+N));
    }

     return  0;
}

转载于:https://www.cnblogs.com/liuxin13/p/4719335.html