JSOI2019精准预测（2-SAT+bitset+乱搞）

题目链接

题解：
考场上的时候似乎还不太会2-SAT，yy了一个出来还写挂了……

暴力的大概思路就是每个时刻，每个人拆成生死两个点，按照2-SAT连边。注意有隐藏条件，就是人死不能复生。
由于大部分点都是没用的，也就是说只有出现在条件的$x$中的点才需要被使用，当然$T+1$时刻肯定也要被用到，那么总共就只有$2(n+m)$个点。

如何判断呢？我们可以两两枚举，判断一个人的活是否能推断出另一个人死，这个可以在$O(n^2)$的时间内判断。这时已经有60分了。

首先我们可以分析出这个图的一些性质，容易发现，我们只会从活向死连边，或者活、死两种状态内部连边。而活、死两种状态的内部由于存在时间差，因此一定无环，所以这整个2-SAT实际上是个DAG，也就是说一定有解，那个解就是所有人一开始就死了。

并且这个2-SAT是完全对称的，若有a->b的边，那么就必然有b’->a’的边。所以最终判断两个人是否能同时存活，只需要判断任意一个人的活是否能推断出另一个人死就行了。于是可以bitset算一波DAG中每个点能到哪。

但是这样会MLE，因为bitset是50000*300000的。题解说要用内存池，实际上分几次跑就好了。大概每次跑10000个点的到达结果，跑5次，似乎是最优的。这样就算完了。

注意如果一个人自己活着能推出自己死了，那么这个人一定不能被统计进答案。

#include 
using namespace std;
typedef long long ll;
typedef pair<int, int> P;

const int MAXN = 50005, MAXM = 100005, MAXV = 300005, B = 10005;
vector<int> dx[MAXN], edge[MAXV];
int opt[MAXM], tim[MAXM], fr[MAXM], to[MAXM], T, n, m;
int beg[MAXN], ed[MAXN], que[MAXV], du[MAXV], res[MAXN];
bitset<B> bt[MAXV];
int main() {
	scanf("%d%d%d", &T, &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d%d%d%d", opt + i, tim + i, fr + i, to + i);
		dx[fr[i]].push_back(tim[i]);
	}
	for (int i = 1; i <= n; i++)
		dx[i].push_back(T + 1);
	for (int i = 1; i <= n; i++) {
		sort(dx[i].begin(), dx[i].end());
		dx[i].resize(unique(dx[i].begin(), dx[i].end()) - dx[i].begin());
		beg[i] = ed[i - 1] + 1;
		ed[i] = beg[i] + dx[i].size() - 1;
		res[i] = n - 1;
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j < (int)dx[i].size(); j++) {
			int a = beg[i] + j - 1, b = a + 1;
			edge[a + ed[n]].push_back(b + ed[n]);
			edge[b].push_back(a);
			++du[b + ed[n]], ++du[a];
		}
	}
	for (int i = 1; i <= m; i++) {
		int a = lower_bound(dx[fr[i]].begin(), dx[fr[i]].end(), tim[i])
			- dx[fr[i]].begin() + beg[fr[i]];
		int b = lower_bound(dx[to[i]].begin(), dx[to[i]].end(), opt[i] ? tim[i] : tim[i] + 1)
			- dx[to[i]].begin() + beg[to[i]];
		if (opt[i]) {
			edge[a].push_back(b + ed[n]);
			edge[b].push_back(a + ed[n]);
			++du[b + ed[n]], ++du[a + ed[n]];
		} else {
			edge[a + ed[n]].push_back(b + ed[n]);
			edge[b].push_back(a);
			++du[b + ed[n]], ++du[a];
		}
	}
	int nn = ed[n] * 2, he = 1, ta = 0;
	for (int i = 1; i <= nn; i++) if (!du[i]) que[++ta] = i;
	while (he <= ta) {
		int u = que[he++];
		for (int v : edge[u])
			if (!(--du[v])) que[++ta] = v;
	}
	assert(ta == nn);
	for (int i = 1; i <= n; i += 10000) {
		int ii = min(i + 9999, n);
		memset(bt, 0, sizeof(bt));
		for (int j = i; j <= ii; j++)
			bt[ed[j] + ed[n]].set(j - i);
		for (int j = ta; j > 0; j--)
		for (int v : edge[que[j]])
			bt[que[j]] |= bt[v];
		bitset<B> tmp;
		for (int j = i; j <= ii; j++)
			if (bt[ed[j]].test(j - i)) res[j] = 0, tmp.set(j - i);
		for (int j = 1; j <= n; j++) if (res[j])
			res[j] -= (bt[ed[j]] | tmp).count();
	}
	for (int i = 1; i <= n; i++) printf("%d ", res[i]);
	return 0;
}