题解：uoj632【UR #21】挑战最大团

题意：给出一个无向图，其满足以下性质：

• 若存在边 \((a,b),(b,c),(c,d)\)，则 \((a,c),(a,d),(b,d)\) 不能同时不存在。

求图中大小为 \(1,2,3\cdots n\) 的团的个数。\(n\le 8000\)。

做法：

直接做是 npc，考虑发掘性质。我们会有以下结论：

• 对于满足条件的图称为好的，那么其补图也是好的。

比较显然，考虑反证那么就等于在原图就会出现违反条件的，矛盾。

• 对于这样的好图，原图和补图不能同时连通。

考虑归纳，现在加入一个新点，那么如果前面原图不连通现在将其全部连通，也就是对目前所有连通块都连一条边，会发现如果其中有点数 \(\ge 2\) 的连通块，那么就会找到一组三条边的结构，这样就会对所有点都连上一条边，此时补图就不会联通；而如果补图不连通，类似上面对补图讨论就可以得到一样的结论。

所以我们现在就可以得出一个做法：考虑对于原图不连通情况，分成两个部分算团的个数然后相加；对于补图不连通，团在补图上就是一个独立集，两边做一个多项式乘法即可。

暴力做用 bfs 算连通性是 \(O(n^3)\)，考虑构造刚好扔掉一个点，复杂度就是 \(\sum i^2 = O(n^3)\)，需要优化。

我们还需要一个性质：

• 好的连通图的直径不超过 \(2\)。

根据定义，如果有两个点距离为 \(3\)，那么中间会加边距离会变小。

由此我们可以找原图和补图中度数最小的点向外扩展两轮即可，这样保证了我们分成两个连通块的时候，复杂度是小的连通块大小乘上两个连通块大小之和，这个东西假设两个连通块大小分别为 \(x,y\)，那么复杂度是 \(O(x(x+y))\)，\(O(xy)\) 可以和树上背包分析一样得到为 \(n^2\)，而 \(x^2\) 部分比 \(xy\) 小，所以总复杂度为 \(O(n^2)\)。

记得在计算的时候同时维护度数，要不然会退化成 \(O(n^2\log n)\)

代码：

#include <bits/stdc++.h>
using namespace std;
#define int long long
#pragma GCC optimize(2)
const int maxn = 8005, mod = 998244353;
int add(int x, int y) {
	x += y;
	return (x >= mod ? x - mod : x);
}
bool f[maxn][maxn];
int n;
inline int get_id(char c) {
	return (isdigit(c) ? c - '0' : c - 'A' + 10);
}
struct Poly {
	vector<int> a;
	int size() {
		return a.size();
	}
	void resize(int N) {
		a.resize(N);
	}
	int& operator[](int x) {
		return a[x];
	}
	friend Poly operator+(Poly f, Poly g) {
		int d = max(f.size(), g.size());
		f.resize(d), g.resize(d);
		for (int i = 0; i < d; i++)
			f[i] = add(f[i], g[i]);
		return f;
	}
	friend Poly operator*(Poly f, Poly g) {
		Poly ans; ans.resize(f.size() + g.size() - 1);
		for (int i = 0; i < f.size(); i++)
			for (int j = 0; j < g.size(); j++)
				ans[i + j] = add(ans[i + j], f[i] * g[j] % mod);
		return ans;
	}
	Poly() {
		a.clear();
	}
};
int deg[maxn], vis[maxn];
Poly solve(vector<int> &p);
pair<int, Poly> cal(vector<int> &p, int k, int s) {
	for (int i = 0; i < p.size(); i++)
		vis[p[i]] = 0;
	vis[s] = 1;
	for (int i = 0; i < p.size(); i++) {
		if(f[s][p[i]] == 1 - k) {
			vis[p[i]] = 1;
			for (int j = 0; j < p.size(); j++) {
				if(!vis[p[j]] && f[p[i]][p[j]] == 1 - k)
					vis[p[j]] = 1;
			}
		}
	}
	int f1 = 1;
	for (int i = 0; i < p.size(); i++) 
		f1 &= vis[p[i]];
	if(f1)
		return make_pair(0, Poly());
	vector<int> lp, rp;
	Poly res;
	for (int i = 0; i < p.size(); i++)
		if(vis[p[i]])
			lp.push_back(p[i]);
		else
			rp.push_back(p[i]);
	for (int i = 0; i < lp.size(); i++)
		for (int j = 0; j < rp.size(); j++)
			deg[lp[i]] -= f[lp[i]][rp[j]],
			deg[rp[j]] -= f[lp[i]][rp[j]];
	if(k)
		res = solve(lp) * solve(rp);
	else
		res = solve(lp) + solve(rp);
	res[0] = 1;
//	for (int i = 0; i < res.size(); i++)
//		cout << res[i] << " ";
//	cout << endl;
	return make_pair(1, res);
}
Poly solve(vector<int> &p) {
	if(p.size() == 1) {
		Poly res; res.resize(2);
		res[0] = res[1] = 1;
		return res;
	}
	int r[2] = {0, 0}, mn[2] = {(int)2e9, (int)2e9};
	for (int i = 0; i < p.size(); i++) {
		int val[2] = {deg[p[i]], (int)p.size() - 1 - deg[p[i]]};
		if(val[0] < mn[0])
			mn[0] = val[0], r[0] = p[i];
		if(val[1] < mn[1])
			mn[1] = val[1], r[1] = p[i];
	}
	int k = (mn[0] < mn[1] ? 0 : 1);
	pair<int, Poly> res = cal(p, k, r[k]);
	if(!res.first)
		return cal(p, 1 - k, r[1 - k]).second;
	return res.second;
}
signed main() {
	ios::sync_with_stdio(false);
	cin >> n;
	for (int i = 1; i < n; i++) {
		string s; cin >> s;
		for (int j = 1; j <= n - i; j++) {
		//	cout << (get_id(s[(j - 1) / 4]) >> ((j - 1) % 4)) << endl;
			f[i][j + i] = ((get_id(s[(j - 1) / 4]) >> ((j - 1) % 4)) & 1), 
			deg[i] += f[i][j + i], deg[j + i] += f[i][j + i],
			f[j + i][i] = f[i][j + i];
		}
	}
	vector<int> p;
	for (int i = 1; i <= n; i++)
		p.push_back(i);
	Poly res = solve(p); res.resize(n + 1);
	for (int i = 1; i <= n; i++)
		cout << res[i] << " ";
	cout << endl;
	return 0;
}