hihocoder1398 网络流五之最大权闭合子图

题目链接：http://hihocoder.com/problemset/problem/1398

题目：

描述

周末，小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 46 3 5 45 2 1 210 2 3 48 3 2 3 4

样例输出

6

解法：

小Ho：这次的问题好像还是很麻烦的样子啊。

小Hi：没错，小Ho你有什么想法么？

小Ho：我么？我能想到只有枚举啦。因为每一项活动都只有举行和不举行两种状态，因此我直接用O(2^N)的枚举，再对选出来的情况进行计算。最后选出最大的方案。

小Hi：这很明显会超过时间限制吧。

小Ho：我知道啊，那有什么好的方法么？

小Hi：当然有啊，这次我们需要解决的是闭合子图问题。

小Ho：这个闭合子图是啥？

小Hi：所谓闭合子图就是给定一个有向图，从中选择一些点组成一个点集V。对于V中任意一个点，其后续节点都仍然在V中。比如：

在这个图中有8个闭合子图：∅,{3},{4},{2,4},{3,4},{1,3,4},{2,3,4},{1,2,3,4}

小Ho：闭合子图我懂了，但是这跟我们这次的问题有啥关系呢？

小Hi：我们先把这次的问题转化为2分图。将N个活动看作A部，将M个学生看作B部。若第i个活动需要第j个学生，就连一条从A[i]到B[j]的有向边。比如对于例子：

假如选择A[1]，则我们需要同时选择B[1],B[2]。那么选择什么活动和其需要的学生，是不是就刚好对应了这个图中的一个闭合子图呢？

小Ho：你这么一说好像还真是。如果把活跃值算作权值，A部的节点包含有正的权值，B部的节点是负的权值。那么我们要求的也就是一个权值最大的闭合子图了？

小Hi：没错，我们要求解的正是最大权闭合子图。它的求解方法是使用网络流，因此我们需要将这个图再进一步转化为网络流图。

对于一般的图来说：首先建立源点s和汇点t，将源点s与所有权值为正的点相连，容量为权值；将所有权值为负的点与汇点t相连，容量为权值的绝对值；权值为0的点不做处理；同时将原来的边容量设置为无穷大。举个例子：

对于我们题目中的例子来说，其转化的网络流图为：

上图中黑边表示容量无穷大的边。

小Ho：转化模型这一步看上去不是太难，然后呢？

小Hi：先说说结论吧，最大权闭合子图的权值等于所有正权点之和减去最小割。

接下来来证明这个结论，首先我们要证明两个引理：

1. 最小割一定是简单割

简单割指得是：割(S,T)中每一条割边都与s或者t关联，这样的割叫做简单割。

因为在图中将所有与s相连的点放入割集就可以得到一个割，且这个割不为正无穷。而最小割一定小于等于这个割，所以最小割一定不包含无穷大的边。因此最小割一定一个简单割。

2. 简单割一定和一个闭合子图对应

闭合子图V和源点s构成S集，其余点和汇点t构成T集。

首先证明闭合子图是简单割：若闭合子图对应的割(S,T)不是简单割，则存在一条边(u,v)，u∈S，v∈T，且c(u,v)=∞。说明u的后续节点v不在S中，产生矛盾。

接着证明简单割是闭合子图：对于V中任意一个点u，u∈S。u的任意一条出边c(u,v)=∞，不会在简单割的割边集中，因此v不属于T，v∈S。所以V的所有点均在S中，因此S-s是闭合子图。

由上面两个引理可以知道，最小割也对应了一个闭合子图，接下来证明最小割就是最大权的闭合子图。

首先有割的容量C(S,T)=T中所有正权点的权值之和+S中所有负权点的权值绝对值之和。

闭合子图的权值W=S中所有正权点的权值之和-S中所有负权点的权值绝对值之和。

则有C(S,T)+W=T中所有正权点的权值之和+S中所有正权点的权值之和=所有正权点的权值之和。

所以W=所有正权点的权值之和-C(S,T)

由于所有正权点的权值之和是一个定值，那么割的容量越小，W也就越大。因此当C(S,T)取最小割时，W也就达到了最大权。

小Ho：我懂了，因为最小割也对应了一个闭合子图，因此它是可以被取得的，W也才能够到达最大权值。

小Hi：没错，这就是前面两条引理的作用。

小Ho：那么最小割的求解就还是用最大流来完成好了！

小Hi：嗯，那就交给你了

代码：

#include <iostream>#include <cstdio>#include <string>#include <cstring>#include <cmath>#include <stack>#include <queue>#include <algorithm>#include <vector>#include <map>#include <set>#include <stdlib.h>#include <iomanip>#include <fstream>using namespace std;#pragma comment(linker, "/STACK:102400000,102400000")#define maxn 1010#define MOD 1000000007#define INF 0x3f3f3f3f#define mem(a , b) memset(a , b , sizeof(a))#define LL long long#define ULL unsigned long long#define FOR(i , n) for(int i = 1 ;  i<= n ; i ++)typedef pair<int , int> pii;int n , m , ed;vector<int>v[maxn];int vis[maxn] , path[maxn] , a[maxn][maxn];int flow[maxn] , ans;bool BFS(){    mem(vis , 0);    mem(path , -1);    mem(flow , 0);    queue<int>q;    while(!q.empty()) q.pop();    q.push(0);    vis[0] = 1;    flow[0] = INF;    while(!q.empty())    {        int cur = q.front();        q.pop();        if(cur == ed) return 1;        for(int i = 0 ; i < v[cur].size() ; i ++)        {            if(!vis[v[cur][i]] && a[cur][v[cur][i]] > 0)            {                vis[v[cur][i]] = 1;                flow[v[cur][i]] = min(flow[cur] , a[cur][v[cur][i]]);                path[v[cur][i]] = cur;                q.push(v[cur][i]);            }        }    }    return 0;}int main(){    while(scanf("%d %d" , &m , &n) != EOF)    {        int s , to;        mem(a , 0);        ed = n + m + 1;        for(int i = 1 ; i <= n ; i ++)        {            scanf("%d" , &to);            v[i+m].push_back(ed);            v[ed].push_back(i+m);            a[i+m][ed] = to;        }        int sum = 0;        for(int i = 1 ; i <= m ; i ++)        {            scanf("%d %d" , &s , &to);            v[0].push_back(i);            v[i].push_back(0);            sum += s;            a[0][i] = s;            for(int j = 0 ; j < to ; j ++)            {                scanf("%d" , &s);                v[i].push_back(m + s);                v[m+s].push_back(i);                a[i][m+s] = INF;            }        }       /* for(int i = 1 ; i <= n ; i ++)        {            v[0].push_back(i);            v[i].push_back(0);            a[0][i] = 1;            v[i+n].push_back(ed);            v[ed].push_back(i+n);            a[i+n][ed] = 1;        }*/        ans = 0;        while(BFS())        {            ans += flow[ed];            int fir = ed , sec = path[fir];            while(sec != -1)            {                a[fir][sec] += flow[ed];                a[sec][fir] -= flow[ed];                fir = sec;                sec = path[fir];            }        }        printf("%d\n" , sum - ans);    }    return 0;}