试题库问题

题目

这是题目

两种做法

网络流

思路

因为是网络流24题网络流十分擅长这种求关系的题目，所以我们优先考虑写网络流。

对于网络流一类的问题，我们优先打开画图软件思考如何建模。

首先我们先把这些题目与类型之间建一条边：

接着再把这些无向边变成有向边，然后再加上源节点S与汇节点T，再把源节点与类型相连，把题目与汇节点相连：

这不就成了一个标准的网络流模型吗？

至于我是怎么想出以上操作的……诶嘿~（试图萌混过关.jpg）

话说这个不是标准套路吗(小声bb)

然后就该考虑如何设置边的容量。

因为每道题只能被选择一次，所以题目到T的边的容量全部设为1。

设类型${}_i$需要选择 $k_i$ 道题，那么经过它流到汇点 T 的流量必须正好为 $k_i$ 。

如果多于 $k_i$ 的话代表你多选了一题，小于 $k_i$ 的话代表已经没有题目可以选择了。

所以我们正好把S到类型${}_i$的边的容量设为 $k_i$，这样你就不可能因为多选题目导致出现奇奇怪怪的错误。

最后就是类型到题目的边了。

可以看出，只要你不把这些边的容量设成小于1的数就行了。

因为题目到汇点 T 的边容量为1，所以无论你把类型到题目的边的容量设到多大，在最大流算法中跑出来的结果都是一样的（如果大到爆int、ll的话当我没说/jk）

要注意的东西

建图之前，边一定要初始化，可见网络流的建图方式（我还暂时没写，有空补上）

网络流求出的最大流就是你选择的题目数量，如果最大流不等于你要选择的题目总和，那么无解。

边不要建反了/kk（某位反复建反边的蒟蒻感觉/kk）

代码

#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 27;
const int M = 2.1e4 + 27;
const int INF = 2e9 + 7;
struct edge {
	int v,c,fail;
}e[M << 1];
int p[N],eid;
void init() {
	memset(p,-1,sizeof p);
	eid = 0;
}
void insert(int u,int v,int c) {
	e[eid].v = v;
	e[eid].c = c;
	e[eid].fail = p[u];
	p[u] = eid ++;
}
void addedge(int u,int v,int c) {
	insert(u,v,c);
	insert(v,u,0);
}
int S,T;
int cur[N],dep[N];
queue<int> q;
bool bfs() {
	memset(dep,-1,sizeof(dep));
	dep[S] = 0; q.push(S);
	while(!q.empty()) {
		int u = q.front();
		q.pop();
		for(int i = p[u];i != -1;i = e[i].fail) {
			int v = e[i].v;
			if(e[i].c > 0 && dep[v] == -1) {
				dep[v] = dep[u] + 1;
				q.push(v);
			}
		}
	}
	return dep[T] != -1;
}
int dfs(int u,int flow) {
	if(u == T) {
		return flow;
	}
	int res = 0;
	for(int i = cur[u];i != -1;i = e[i].fail) {
		cur[u] = i;
		int v = e[i].v;
		if(e[i].c > 0 && dep[v] == dep[u] + 1) {
			int maxflow = dfs(v,min(flow,e[i].c));
			e[i].c -= maxflow;
			flow -= maxflow;
			res += maxflow;
			e[i ^ 1].c += maxflow;
			if(flow == 0) {
				break;
			}
		}
	}
	if(res == 0) {
		dep[u] = -1;
	}
	return res;
}
int Dinic() {
	int res = 0;
	while(bfs()) {
		memcpy(cur,p,sizeof cur);
		res += dfs(S,INF);
	}
	return res;
}
int n,k,m;
int main() {
	init(); S = 0;
	scanf("%d%d",&k,&n);
	T = k + n + 1;
	for(int v = 1;v <= k;++ v) {
		int flow;
		scanf("%d",&flow);
		addedge(S,v,flow);
		m += flow;
	}
	for(int v = k + 1;v <= k + n;++ v) {
		int cnt,u;
		scanf("%d",&cnt);
		for(int i = 1;i <= cnt;++ i) {
			scanf("%d",&u);
			addedge(u,v,1);
		}
	}
	for(int u = k + 1;u <= n + k;++ u) {
		addedge(u,T,1);
	}
	if(Dinic() != m) {
		printf("No Solution!");
		return 0;
	}
	for(int u = 1;u <= k;++ u) {
		printf("%d:",u);
		for(int j = p[u];j != -1;j = e[j].fail) {
			int v = e[j].v;
			if(v != 0 && e[j ^ 1].c > 0) {
				printf(" %d",v - k);
			}
		}
		printf("\n");
	}
	return 0;
}

匈牙利算法

直接最大二分图匹配，十分无脑。

但这不属于网络流的范围，本蒟蒻不给予任何思路与代码上的参考。