HDU4289 Control —— 最小割、最大流 、拆点

题目链接：https://vjudge.net/problem/HDU-4289

Control

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3829    Accepted Submission(s): 1610

Problem Description

　　You, the head of Department of Security, recently received a top-secret information that a group of terrorists is planning to transport some WMD ¹ from one city (the source) to another one (the destination). You know their date, source and destination, and they are using the highway network.
　　The highway network consists of bidirectional highways, connecting two distinct city. A vehicle can only enter/exit the highway network at cities only.
　　You may locate some SA (special agents) in some selected cities, so that when the terrorists enter a city under observation (that is, SA is in this city), they would be caught immediately.
　　It is possible to locate SA in all cities, but since controlling a city with SA may cost your department a certain amount of money, which might vary from city to city, and your budget might not be able to bear the full cost of controlling all cities, you must identify a set of cities, that:
　　* all traffic of the terrorists must pass at least one city of the set.
　　* sum of cost of controlling all cities in the set is minimal.
　　You may assume that it is always possible to get from source of the terrorists to their destination.
------------------------------------------------------------
¹ Weapon of Mass Destruction

 

Input

　　There are several test cases.
　　The first line of a single test case contains two integer N and M ( 2 <= N <= 200; 1 <= M <= 20000), the number of cities and the number of highways. Cities are numbered from 1 to N.
　　The second line contains two integer S,D ( 1 <= S,D <= N), the number of the source and the number of the destination.
　　The following N lines contains costs. Of these lines the ith one contains exactly one integer, the cost of locating SA in the ith city to put it under observation. You may assume that the cost is positive and not exceeding 10⁷.
　　The followingM lines tells you about highway network. Each of these lines contains two integers A and B, indicating a bidirectional highway between A and B.
　　Please process until EOF (End Of File).

 

Output

　　For each test case you should output exactly one line, containing one integer, the sum of cost of your selected set.
　　See samples for detailed information.

 

Sample Input

5 6
5 3
5
2
3
4
12
1 5
5 4
2 3
2 4
4 3
2 1

 

Sample Output

3

 

Source

2012 ACM/ICPC Asia Regional Chengdu Online

 

Recommend

liuyiding

题意：

有n个城市，m条路（无向），一些恐怖分子准备从S城市出发，运送一些大规模杀伤性武器到城市D。于是警察准备在一些城市作部署，以防止大规模杀伤性武器能够到达目的地，即把城市S和城市D割裂开，且部署每一个城市都有其特定的花费。问：怎样用最少的花费来完成任务？

题解：

可知为求权值和最小的割点集，但是又不能用Tarjan算法去做。所以可以适当变形：把每个城市拆成两个点u和u'，u和u'之间连一条有有向边：u-->u'，且权值为部署这个城市所需要的花费。这样，就把问题转化为求最小割了，求最小割又可以转化为求最大流。以下是具体建图：

1.把每个城市拆成两个点u和u'，u和u'之间连一条有有向边：u-->u'，且权值为部署这个城市所需要的花费。

2.对于每个相邻的城市，连上一条无向边，且权值为INF。

代码如下：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <cmath>
 #include <queue>
 #include <stack>
 #include <map>
 #include <string>
 #include <set>
 using namespace std;
 typedef long long LL;
 const int INF = 2e9;
 const LL LNF = 9e18;
 const int mod = 1e9+;
 const int MAXN = 4e2+;

 int maze[MAXN][MAXN];
 int gap[MAXN], dis[MAXN], pre[MAXN], cur[MAXN];
 int flow[MAXN][MAXN];

 int sap(int start, int end, int nodenum)
 {
     memset(cur, , sizeof(cur));
     memset(dis, , sizeof(dis));
     memset(gap, , sizeof(gap));
     memset(flow, , sizeof(flow));
     int u = pre[start] = start, maxflow = , aug = INF;
     gap[] = nodenum;

     while(dis[start]<nodenum)
     {
         loop:
         for(int v = cur[u]; v<nodenum; v++)
         if(maze[u][v]-flow[u][v]> && dis[u] == dis[v]+)
         {
             aug = min(aug, maze[u][v]-flow[u][v]);
             pre[v] = u;
             u = cur[u] = v;
             if(v==end)
             {
                 maxflow += aug;
                 for(u = pre[u]; v!=start; v = u, u = pre[u])
                 {
                     flow[u][v] += aug;
                     flow[v][u] -= aug;
                 }
                 aug = INF;
             }
             goto loop;
         }

         int mindis = nodenum-;
         for(int v = ; v<nodenum; v++)
             if(maze[u][v]-flow[u][v]> && mindis>dis[v])
             {
                 cur[u] = v;
                 mindis = dis[v];
             }
         if((--gap[dis[u]])==) break;
         gap[dis[u]=mindis+]++;
         u = pre[u];
     }
     return maxflow;
 }

 int main()
 {
     int n, m, start, end;
     while(scanf("%d%d", &n,&m)!=EOF)
     {
         scanf("%d%d", &start, &end);
         start = start-; end = n+end-;
         memset(maze, , sizeof(maze));
         for(int i = ; i<n; i++)
         {
             int cost;
             scanf("%d", &cost);
             maze[i][n+i] = cost;
         }
         for(int i = ; i<m; i++)
         {
             int u, v;
             scanf("%d%d", &u, &v);
             u--; v--;
             maze[n+u][v] = INF;
             maze[n+v][u] = INF;
         }

         cout<< sap(start, end, *n) <<endl;
     }
 }