题意:

                          现在给出在一些N位置建造基站的费用..基站建立后就可以与其他的基站进行通信。而现在有M个用户..每个人要求某两点要能通信(这两个位置上建造了基站)..并且其会支付一些费用..问最多能赚多少费用....

                  题解:

                          ​​ 大牛博客​​说得比较清楚... 

                          所谓闭合子图是指在一个有向图中存在的这么一个子图,若有边(u,v)并且u属于闭合子图中那么v就必须在闭合图中...可以理解为(u,v)为一个必要关系(有了u就必须要有v)..而最大权闭合子图.就是每个点有权值.点权之和最大的就是最大权闭合子图...

                          而本题就是这么个意思..有M+N个点.前M个点代表的是用户..其点权为满足该用户的必要条件这个用户会支付的钱..而后N个代表的是在N个位置建造基站..点权为其代价..所有的用户向其所要求的基站做边..代表要选择该用户就必须选择其指向的基站...现在问题已经完全抽象成最大权闭合子图的模型了...

                          下面就是如何来求解这个模型的值:

                           1、超级源点向所有的用户做边，容量为其能支付的费用，并且把所有的收益加起来记为sum

                           2、每个用户向其所要求的基站做边，容量为无穷大。

                           3、每个基站向超级汇点做边，容量为建造这个基站所需的费用。

                           4、sum-MaxFlow(超级源点->超级汇点) 就是答案


Program:

#include<iostream>      
#include<algorithm>      
#include<stdio.h>      
#include<string.h>    
#include<time.h>   
#include<map>   
#include<math.h>      
#include<queue>      
#define MAXN 100005
#define MAXM 500005 
#define oo 1000000007      
#define ll long long      
using namespace std;     
struct Dinic                
{                
       struct node              
       {               
             int c,u,v,next;              
       }edge[MAXM];              
       int ne,head[MAXN];              
       int cur[MAXN], ps[MAXN], dep[MAXN];            
       void initial()              
       {              
             ne=2;              
             memset(head,0,sizeof(head));               
       }              
       void addedge(int u, int v,int c)              
       {               
             edge[ne].u=u,edge[ne].v=v,edge[ne].c=c,edge[ne].next=head[u];              
             head[u]=ne++;              
             edge[ne].u=v,edge[ne].v=u,edge[ne].c=0,edge[ne].next=head[v];              
             head[v]=ne++;              
       }              
       int MaxFlow(int s,int t)              
       {                                   
             int tr, res = 0;              
             int i,j,k,f,r,top;              
             while(1)              
             {              
                    memset(dep, -1, sizeof(dep));              
                    for(f=dep[ps[0]=s]=0,r=1;f!= r;)              
                       for(i=ps[f++],j=head[i];j;j=edge[j].next)              
                         if(edge[j].c&&dep[k=edge[j].v]==-1)              
                         {              
                               dep[k]=dep[i]+1;              
                               ps[r++]=k;              
                               if(k == t){  f=r; break;  }              
                         }              
                    if(dep[t]==-1) break;              
                    memcpy(cur,head,sizeof(cur));              
                    i=s,top=0;              
                    while(1)              
                    {              
                         if(i==t)              
                         {              
                               for(tr=oo,k=0;k<top;k++)              
                                  if(edge[ps[k]].c<tr)              
                                     tr=edge[ps[f=k]].c;              
                               for(k=0;k<top;k++)              
                               {              
                                     edge[ps[k]].c-=tr;              
                                     edge[ps[k]^1].c+=tr;              
                               }              
                               i=edge[ps[top=f]].u;              
                               res+= tr;              
                         }              
                         for(j=cur[i];cur[i];j=cur[i]=edge[cur[i]].next)               
                             if(edge[j].c && dep[i]+1==dep[edge[j].v]) break;               
                         if(cur[i])  ps[top++]=cur[i],i=edge[cur[i]].v;               
                         else              
                         {              
                                 if(!top) break;              
                                 dep[i]=-1;              
                                 i=edge[ps[--top]].u;              
                         }              
                   }              
             }              
             return res;              
      }         
}T;           
int main()     
{         
      int N,M,i,s,e,u,v,c,sum;
      while (~scanf("%d%d",&N,&M))
      {
               s=N+M+1,e=s+1,T.initial();
               for (i=1;i<=N;i++) scanf("%d",&c),T.addedge(i+M,e,c);
               sum=0;
               for (i=1;i<=M;i++)
               {
                        scanf("%d%d%d",&u,&v,&c),sum+=c;
                        T.addedge(i,u+M,oo),T.addedge(i,v+M,oo);
                        T.addedge(s,i,c);
               }
               printf("%d\n",sum-T.MaxFlow(s,e));
      }
      return 0;    
}