hdu 3879 Base Station 最大权闭合图

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3879

A famous mobile communication company is planning to build a new set of base stations. According to the previous investigation, n places are chosen as the possible new locations to build those new stations. However, the condition of each position varies much, so the costs to built a station at different places are different. The cost to build a new station at the ith place is P_i (1<=i<=n).

When complete building,
two places which both have stations can communicate with each
other.

Besides, according to the marketing department, the company has
received m requirements. The ith requirement is represented by three integers
A_i, B_i and C_i, which means if place A_i
and B_i can communicate with each other, the company will get
C_i profit.

Now, the company wants to maximize the profits, so
maybe just part of the possible locations will be chosen to build new stations.
The boss wants to know the maximum profits.

 

题意描述：有n个城市，在城市 i 建立新的驿站的花费为Pi，如果两个城市都有驿站则可以互相通信交流并且公司会因此获取到利益，比如A城市和B城市相互通信，那么可以获取到C的利益。问最大利益是多少。

算法分析：最大权闭合图。把两个城市相互通信的这条边看作点，比如A B C（如题意描述中解释），A和B的这条边看作点U，连边from到U，权值为C，连边U到A、U到B，权值为无穷大，连边A到to，B到to，权值为在此城市建立驿站的花费。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cstdlib>
 #include<cmath>
 #include<algorithm>
 #include<queue>
 #define inf 0x7fffffff
 using namespace std;
 const int maxn=+;
 const int M = +;

 int n,m,from,to;
 struct node
 {
     int v,flow;
     int next;
 }edge[M*];
 int head[maxn],edgenum;

 void add(int u,int v,int flow)
 {
     edge[edgenum].v=v ;edge[edgenum].flow=flow;
     edge[edgenum].next=head[u] ;head[u]=edgenum++ ;

     edge[edgenum].v=u ;edge[edgenum].flow=;
     edge[edgenum].next=head[v] ;head[v]=edgenum++ ;
 }

 int d[maxn];
 int bfs()
 {
     memset(d,,sizeof(d));
     d[from]=;
     queue<int> Q;
     Q.push(from);
     while (!Q.empty())
     {
         int u=Q.front() ;Q.pop() ;
         for (int i=head[u] ;i!=- ;i=edge[i].next)
         {
             int v=edge[i].v;
             if (!d[v] && edge[i].flow)
             {
                 d[v]=d[u]+;
                 Q.push(v);
                 if (v==to) return ;
             }
         }
     }
     return ;
 }

 int dfs(int u,int flow)
 {
     if (u==to || flow==) return flow;
     int cap=flow;
     for (int i=head[u] ;i!=- ;i=edge[i].next)
     {
         int v=edge[i].v;
         if (d[v]==d[u]+ && edge[i].flow)
         {
             int x=dfs(v,min(edge[i].flow,cap));
             edge[i].flow -= x;
             edge[i^].flow += x;
             cap -= x;
             if (cap==) return flow;
         }
     }
     return flow-cap;
 }

 int dinic()
 {
     int sum=;
     while (bfs()) sum += dfs(from,inf);
     return sum;
 }

 int an[maxn];
 int main()
 {
     while (scanf("%d%d",&n,&m)!=EOF)
     {
         memset(head,-,sizeof(head));
         edgenum=;
         from=n+m+;
         to=from+;
         for (int i= ;i<=n ;i++)
         {
             scanf("%d",&an[i]);
             add(i,to,an[i]);
         }
         int a,b,c;
         int sum=;
         for (int i= ;i<=m ;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             sum += c;
             add(from,n+i,c);
             add(n+i,a,inf);
             add(n+i,b,inf);
         }
         printf("%d\n",sum-dinic());
     }
     return ;
 }