网络流专题 最大权闭合子图

 网络流五·最大权闭合子图

时间限制:10000ms

单点时限:1000ms

内存限制:256MB

描述

周末，小Hi和小Ho所在的班级决定举行一些班级建设活动。

根据周内的调查结果，小Hi和小Ho一共列出了N项不同的活动(编号1..N)，第i项活动能够产生a[i]的活跃值。

班级一共有M名学生(编号1..M)，邀请编号为i的同学来参加班级建设活动需要消耗b[i]的活跃值。

每项活动都需要某些学生在场才能够进行，若其中有任意一个学生没有被邀请，这项活动就没有办法进行。

班级建设的活跃值是活动产生的总活跃值减去邀请学生所花费的活跃值。

小Hi和小Ho需要选择进行哪些活动，来保证班级建设的活跃值尽可能大。

 
 

比如有3项活动，4名学生：

第1项活动产生5的活跃值，需要编号为1、2的学生才能进行；

第2项活动产生10的活跃值，需要编号为3、4的学生才能进行；

第3项活动产生8的活跃值，需要编号为2、3、4的学生才能进行。

编号为1到4的学生需要消耗的活跃值分别为6、3、5、4。

假设举办活动集合为{1}，需要邀请的学生集合为{1,2}，则得到的班级活跃值为5-9 = -4。

假设举办活动集合为{2}，需要邀请的学生集合为{3,4}，则得到的班级活跃值为10-9 = 1。

假设举办活动集合为{2,3}，需要邀请的学生集合为{2,3,4}，则得到的班级活跃值为18-12 = 6。

假设举办活动集合为{1,2,3}，需要邀请的学生集合为{1,2,3,4}，则得到的班级活跃值为23-18 = 5。

小Hi和小Ho总是希望班级活跃值越大越好，因此在这个例子中，他们会选择举行活动2和活动3。

提示：最大权闭合子图

 

输入

第1行：两个正整数N,M。1≤N≤200，1≤M≤200

第2行：M个正整数，第i个数表示邀请编号为i的学生需要花费的活跃值b[i]，1≤b[i]≤1,000

第3..N+2行：第i行表示编号为i的活动情况。首先是2个整数a,k，a表示该活动产生的活跃值，k表示该活动需要的学生人数。接下来k个整数列举该活动需要的学生编号。1≤a≤1,000，1≤k≤M

输出

第1行：1个整数，最大可以产生的班级活跃值

样例输入

3 4
6 3 5 4
5 2 1 2
10 2 3 4
8 3 2 3 4

样例输出

6

解题思路：这一个是太空飞行计划的弱化版，分析见上一篇。

注意：边数不能开太小。。。

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<set>
#include<algorithm>
#include<cstring>
using namespace std;
#define rep(i,j,k) for(int i=j;i<=k;i++)
#define sca(x) scanf("%d",&x)
#define per(i,j,k) for(int i=j;i>=k;i--)
#define inf 0x3f3f3f3f
#define LL long long
#define N 20000
#define inf 0x3f3f3f3f

struct edg
{
    int to,w,nt;
}g[N];

int b[405];
int dep[405],head[405];
bool  bfs(int s,int t)
{
    memset(dep,0,sizeof(dep));
    dep[s]=1;
    queue<int>q;
    q.push(s);
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i!=-1;i=g[i].nt)
        {
            int to=g[i].to;
            if(!dep[to]&&g[i].w>0)
            {
                dep[to]=dep[u]+1;
                q.push(to);
            }
        }
    }
    return dep[t]==0?false:true;
}

int dfs(int s,int t,int flow)
{
    int now=0;
    if(s==t)return flow;
    for(int i=head[s];i!=-1;i=g[i].nt)
    {
        int to=g[i].to;
        if(dep[to]==dep[s]+1&&g[i].w>0
          &&(now=dfs(to,t,min(flow,g[i].w))))
        {
            g[i].w-=now;
            g[i^1].w+=now;
            return now;
        }
    }
    return 0;
}

int Dinic(int s,int t)
{
    int ans=0;
    int d;
    while(bfs(s,t))
    {
        while(d=dfs(s,t,inf))
            ans+=d;
    }
    return ans;
}

int tot;
void addedg(int u,int v,int w)
{
    g[tot].to=v;
    g[tot].w=w;
    g[tot].nt=head[u];
    head[u]=tot++;
}

int main()
{
    int n,m,xx;
    scanf("%d%d",&n,&m);
    rep(i,1,m)sca(b[i]);
    int tmp,sum=0;
    memset(head,-1,sizeof(head));
    rep(i,1,n)
    {
        sca(tmp);
        sum+=tmp;
        addedg(0,i,tmp);
        addedg(i,0,0);
        sca(xx);
        rep(j,1,xx)
        {
            sca(tmp);
            addedg(i,n+tmp,inf);
            addedg(n+tmp,i,0);
        }
    }
    rep(i,1,m)
    {
        addedg(n+i,n+201,b[i]);
        addedg(n+201,n+i,0);
    }
    printf("%d\n",sum-Dinic(0,n+201));
}