LOJ 「网络流 24 题」太空飞行计划(最大权闭合子图)

https://loj.ac/problem/6001

原来还有这种操作。

这种最大权闭合子图问题的套路就是：

权值为正的，从源点向该点连一条流量为权值大小的边。

权值为负的，从该点向汇点连一条流量为权值大小的边。

原本的有关系的两个点之间连接一条流量为无穷大的边。

最后得到的最大收益 = 权值为正的点的权值之和 - 跑一遍网络流得到的最小割。

为什么会是这个结果呢？

1.如果每个方案的资金都是大于买仪器设备的花费的，那么很明显最小割就是仪器花费之和，我们直接用收益减去花费就是答案。

2.如果有的方案的资金是小于买仪器设备的花费的，我们直接来改改样例中的数据。

2 3
10 1 2
25 3
5 6 7

那么我们第一次用dinic找完最小割后，又会回到bfs，此时由于到达实验1的边流量为0，所以我们不会把实验1加入，

因为他的花费为11把他的流量全用完了，就不用他了。

然后第二个实验因为还有剩余流量，所以是要用上的。

那么再看看，我们得到的最小割大小为18，其中第一个实验的资金全部都用完了，其实撑死了也就是把实验一的资金用完了，我们用总的正的权值之和减去这个最小割，

不就相当于实验一没有参与吗？所以最后结果依然是实验二赚得钱。

3.如果有的方案的资金等于买仪器的花费的话。。。这就很尴尬了。按照上面的分析，我们是不会输出这种方案的。如果是要输出这种方案的话。。。我能想到的就是暴力先

看看这个方案是不是等于的，等于也记录一下。。。然而loj上没有这种数据就很happy

代码如下：

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
const int maxn = 105;
const int maxm = 10005;
const int INF = 0x3f3f3f3f;
using namespace std;

bool vst[maxn];

inline int read()
{
	int x=0,t=1,c;
	while(!isdigit(c=getchar()))if(c=='-')t=-1;
	while(isdigit(c))x=x*10+c-'0',c=getchar();
	return x*t;
}
int head[maxn],cur[maxn],nx[maxm<<1],to[maxm<<1],flow[maxm<<1],ppp=2;
struct Dinic
{
	int d[maxn];
	int s,t;
	long long ans;
	void AddEdge(int u,int v,int c)
	{
		to[ppp]=v;flow[ppp]=c;nx[ppp]=head[u];head[u]=ppp++;swap(u,v);
		to[ppp]=v;flow[ppp]=0;nx[ppp]=head[u];head[u]=ppp++;
	}
	bool BFS()
	{
		memset(d,-1,sizeof d);
		memset(vst, 0, sizeof(vst));
		d[s]=1;
		vst[s] = 1;
		queue<int> Q;
		Q.push(s);
		while(!Q.empty())
		{
			int x=Q.front();
			Q.pop();
			for(int i=head[x];i;i=nx[i])
			{
				if(flow[i] && d[to[i]]==-1)
				{
					vst[to[i]] = 1;
					d[to[i]]=d[x]+1;
					Q.push(to[i]);
				}
			}
		}
		return d[t]!=-1;
	}
	int DFS(int x,int maxflow)
	{
		if(x==t||!maxflow){
			ans+=maxflow;
			return maxflow;
		}
		int ret=0,f;
		for(int &i=cur[x];i;i=nx[i])
		{
			if(d[to[i]]==d[x]+1&&(f=DFS(to[i],min(maxflow,flow[i]))))
			{
				ret+=f;
				flow[i]-=f;
				flow[i^1]+=f;
				maxflow-=f;
				if(!maxflow)
					break;
			}
		}
		return ret;
	}
	long long solve(int source,int tank)
	{
		s=source;
		t=tank;
		ans=0;
		while(BFS())
		{
//			cout << "hello\n";
			memcpy(cur,head,sizeof(cur));
			DFS(s,INF);
		}
		return ans;
	}
}dinic;

void mysolve(int m, int n)  {
	
	bool flag = 1;
	for(int i = 1; i <= m; i++) {
		if(vst[i]) {
			if(flag) {
				flag = 0;
				printf("%d", i);
			} else {
				printf(" %d", i);
			}
		}
	}
	puts("");
	
	flag = 1;
	for(int i = m + 1; i <= m + n; i++) {
		if(vst[i]) {
			if(flag) {
				flag = 0;
				printf("%d", i - m);
			} else {
				printf(" %d", i - m);
			}
		}
	}
	puts("");
}

int main()
{
	long long sum = 0;
	int m=read(),n=read();
	for(int i = 1; i <= m; i++)
	{
		int c=read();
		dinic.AddEdge(0,i,c);
		sum += c;
		int t;
		scanf("%d", &t);
		dinic.AddEdge(i, m + t, INF);
		char ch = getchar();
		while(ch != '\n') {
			scanf("%d", &t);
			dinic.AddEdge(i, m + t, INF);
			ch = getchar();
		}
	}
	for(int i = 1; i <= n; i++) {
		int t = read();
		dinic.AddEdge(m + i, n + m + 1, t);
	}
	long long tmp = dinic.solve(0,n + m + 1);
	
	mysolve(m, n);
	
	printf("%lld\n", sum - tmp);
	return 0;
}