HDU 4971 A simple brute force problem.(最小割，最大权闭合图)

题意：

给出n个项目，m个问题，完成某个项目需要解决一些问题，解决某个问题可能要先解决另一个问题，比如问题i依赖于问题j，那要先解决j再解决i，如果互相依赖，则要同时解决。完成某个项目会获得收益，解决某个问题需要一些花费，求最大净收益。

分析：

就是个最大权闭合图，幸好以前做过一道，并且还记得建图的方法，于是在刚过的网络流的代码上改了两下就AC了。

建图方法：项目是正权点，权值为收益，问题为负权点，权值为花费。项目对所要解决的问题连边，容量为INF;增加源点，连向正权点，容量为收益;增加汇点，负权点向其连边，容量为花费。最大权和为正权和减去上图中的最小割。

各个工程之间连边，流量为该工程的收益，然后各个技术与汇点连边，流量为学习该技术的花费，然后是技术与技术之间，如果学习技术 i 要先学习技术 j，则从 i 向 j 连边，流量为正无穷，最后是工程与技术之间，若工程 i 需要技术 j ，则从 i 想 j 连边，流量为该工程的收益，跑一遍最大流，答案为所有工程的总收益减最大流

#include <cstdio>
#include <algorithm>
#include <cstring>
#define LL long long
#define itn int
#define maxn 1007
#define maxm 2333333
#define INF 0x3f3f3f3f
using namespace std;


int a[maxn],b[maxn];
int fir[maxn];
itn u[maxm],v[maxm],cap[maxm],flow[maxm],nex[maxm];
int e_max;
itn q[maxn<<2];

itn lv[maxn],iter[maxn];

void add_edge(int _u,int _v,int _w)
{

    int e=e_max++;
    u[e]=_u;v[e]=_v;cap[e]=_w;
    nex[e]=fir[u[e]];fir[u[e]]=e;
    e=e_max++;
    u[e]=_v;v[e]=_u;cap[e]=0;
    nex[e]=fir[u[e]];fir[u[e]]=e;
}

void dinic_bfs(itn s)
{
    int f,r;
    lv[s]=0;
    q[f=r=0]=s;

    while (f<=r)
    {
        int x=q[f++];
        for (int e=fir[x];~e;e=nex[e])
        {
            if (cap[e]>flow[e] && lv[v[e]]<0)
            {
                lv[v[e]]=lv[u[e]]+1;
                q[++r]=v[e];
            }
        }
    }
}

int dinic_dfs(int s,int t,int _f)
{
    if (s==t)   return _f;

    for (int &e=iter[s];~e;e=nex[e])
    {
        if (cap[e]>flow[e] && lv[s]<lv[v[e]])
        {
            int _d=dinic_dfs(v[e],t,min(cap[e]-flow[e],_f));
            if (_d>0)
            {
                flow[e]+=_d;
                flow[e^1]-=_d;
                return _d;
            }
        }
    }

    return 0;
}


itn max_flow(int s,int t)
{
    int total_flow=0;

    memset(flow,0,sizeof flow);
    for (;;)
    {
        memset(lv,-1,sizeof lv);
        dinic_bfs(s);

        if (lv[t]==-1)  break;

        memcpy(iter,fir,sizeof fir);

        itn _f=0;
        while ((_f=dinic_dfs(s,t,INF))>0)
            total_flow+=_f;

    }

    return total_flow;

}

int main()
{
    int n,m;
    itn T_T,cas=0;
    scanf("%d",&T_T);

    while(T_T--)
    {
        printf("Case #%d: ",++cas);
        scanf("%d%d",&n,&m);
        itn s=0,t=n+m+1;
        itn sr=0,sc=0;
        e_max=0;
        memset(fir,-1,sizeof fir);
        for (int i=1;i<=n;i++)
        {
            scanf("%d",a+i);
            add_edge(s,i,a[i]);
            sr+=a[i];
        }

        for (int i=1;i<=m;i++)
        {
            scanf("%d",b+i);
            add_edge(i+n,t,b[i]);
        }

        for (int i=1,k,p;i<=n;i++)
        {
            scanf("%d",&k);
            for (int j=0;j<k;j++)
            {
                scanf("%d",&p);
                p++;
                add_edge(i,p+n,INF);
            }

        }

        int x;
        for (int i=1;i<=m;i++)
        {
            for (int j=1;j<=m;j++)
            {
                scanf("%d",&x);
                if (x)
                add_edge(i+n,j+n,INF);
            }
        }

        int res=sr-max_flow(s,t);
        
        printf("%d\n",res);
    }


    return 0;
}