A Car Show
题意:给定长度为 n n n 的序列 { a i } \{a_i\} {ai},其中 a i ∈ [ 1 , m ] a_i \in [1,m] ai∈[1,m],求有多少个连续子区间包含 [ 1 , m ] [1,m] [1,m] 中每个数。 n , m ≤ 1 × 1 0 5 n, m\leq 1\times 10^5 n,m≤1×105。
解法:使用双指针即可。时间复杂度 O ( n ) \mathcal O(n) O(n)。
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int cnt[N + 5], a[N + 5];
int main()
{
int n, m;
scanf("%d%d", &n, &m);
long long ans = 0;
for (int i = 1; i <= n;i++)
scanf("%d", &a[i]);
int now = 0;
for (int l = 1, r = 1; l <= n;l++)
{
while (r <= n && now < m)
{
if(!cnt[a[r]])
now++;
cnt[a[r]]++;
r++;
}
if (now == m)
ans += n - r + 2;
cnt[a[l]]--;
if (!cnt[a[l]])
now--;
}
printf("%lld", ans);
return 0;
}
B Two Frogs
题意:有一长度为 n n n 的数轴和 2 2 2 个青蛙,初始均在 1 1 1 号点,在第 i i i 号点两个青蛙都以等概率跳到 [ i + 1 , i + a i ] [i+1,i+a_i] [i+1,i+ai] 号点,问两青蛙以相同次数跳跃抵达 n n n 号点的概率。 n ≤ 8 × 1 0 3 n \leq 8\times 10^3 n≤8×103。
解法:计算出单个青蛙的答案即可。设 f i , j f_{i,j} fi,j 为在 i i i 号点,还需要跳跃 j j j 次抵达 n n n 号点的概率,则答案为 ∑ i = 1 n f 1 , i 2 \displaystyle \sum_{i=1}^n f_{1,i}^2 i=1∑nf1,i2。其转移非常显然: f i , j = 1 a i ∑ k = 1 a i f i + k , j − 1 \displaystyle f_{i,j}=\dfrac{1}{a_i}\sum_{k=1}^{a_i}f_{i+k,j-1} fi,j=ai1k=1∑aifi+k,j−1。使用后缀和优化即可,整体复杂度 O ( n 2 ) \mathcal O(n^2) O(n2)。
#include <bits/stdc++.h>
using namespace std;
const int N = 8000;
const long long mod = 998244353;
long long power(long long a, long long x)
{
long long ans = 1;
while(x)
{
if (x & 1)
ans = ans * a % mod;
a = a * a % mod;
x >>= 1;
}
return ans;
}
int a[N + 5], f[N + 5][N + 5], suf[N + 5][N + 5];
long long inv[N + 5];
int main()
{
int n;
scanf("%d", &n);
inv[1] = 1;
for (int i = 2; i <= n; i++)
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i <= n;i++)
scanf("%d", &a[i]);
f[n][0] = suf[n][0] = 1;
for (int i = n - 1; i >= 1; i--)
{
suf[i][0] = suf[i + 1][0];
for (int j = 1; j <= n; j++)
f[i][j] = 1ll * (suf[i + 1][j - 1] - suf[i + a[i] + 1][j - 1] + mod) % mod * inv[a[i]] % mod,
suf[i][j] = (suf[i + 1][j] + f[i][j]) % mod;
}
long long ans = 0;
for (int i = 1; i <= n; ++i)
ans = (ans + 1ll * f[1][i] * f[1][i] % mod) % mod;
printf("%lld", ans);
return 0;
}
C Global Positioning System
题意:给定 n n n 个点 m m m 条边的图,图上每条边有一向量。现在这些边上的向量恰好有一个错误的,原始的图上任意环上向量和为 0 ⃗ \vec 0 0,找出有多少个可能错误的边。 n , m ≤ 1 × 1 0 5 n,m \leq 1\times 10^5 n,m≤1×105。
解法:首先找到任意一个生成森林,考虑非树边的加入会对答案造成什么影响:
- 当前边 ( u , v ) (u,v) (u,v) 的加入不会造成冲突。那么对于链 u → l c a ( u , v ) u \to {\rm lca}(u,v) u→lca(u,v) 与 v → l c a ( u , v ) v \to {\rm lca}(u, v) v→lca(u,v) 均不能出现错误。
- 当前边 ( u , v ) (u,v) (u,v) 的加入导致了错误。则有以下两种子情况:树边错误与 ( u , v ) (u,v) (u,v) 错误。在树上对 u → l c a ( u , v ) u \to {\rm lca}(u,v) u→lca(u,v) 与 v → l c a ( u , v ) v \to {\rm lca}(u, v) v→lca(u,v) 链打标记,记录错误次数。同时 ( u , v ) (u,v) (u,v) 边也打上标记,表示可能错误。
最后统计答案的时候,找到所有错误的边的交集,对于树边必然是这些答案中的一个(注意要去掉不允许出错的正确环)。若只有一条非树边的加入导致了错误,则当前错误非树边也可能是错误的。
#include<bits/stdc++.h>
#define IL inline
#define LL long long
using namespace std;
const int N=5e5+3;
struct poi{
LL x,y,z;
poi operator+(const poi &a) const{
return (poi){x+a.x,y+a.y,z+a.z};}
poi operator-(const poi &a) const{
return (poi){x-a.x,y-a.y,z-a.z};}
poi operator*(const int k) const{
return (poi){x*k,y*k,z*k};}
IL int chk(){return !x&&!y&&!z;}
}dis[N];
struct hh{
int to,nxt,id;poi w;
}e[N<<1];
struct line{
int x,y,id;poi w;
}l[N],re[N];
int n,m,num,cnt,fir[N],fa[N][22],vis[N],f[N],dep[N],val[N],id[N],bo[N],ban[N];
vector<line>er;vector<int>ans;
IL int in(){
char c;int f=1;
while((c=getchar())<'0'||c>'9')
if(c=='-') f=-1;
int x=c-'0';
while((c=getchar())>='0'&&c<='9')
x=x*10+c-'0';
return x*f;
}
IL void add(int x,int y,int pos,poi w){
e[++num]=(hh){y,fir[x],pos,w},fir[x]=num;
e[++num]=(hh){x,fir[y],pos,w*-1},fir[y]=num;
}
int find(int x){return x^f[x]?f[x]=find(f[x]):x;}
void dfs1(int u,int f){
vis[u]=1,dep[u]=dep[f]+1,fa[u][0]=f;
for(int i=0;fa[u][i];++i)
fa[u][i+1]=fa[fa[u][i]][i];
for(int i=fir[u],v;v=e[i].to;i=e[i].nxt)
if(v^f) dis[v]=dis[u]+e[i].w,dfs1(v,u);
}
IL int Lca(int x,int y){
if(dep[x]<dep[y]) swap(x,y);
for(int i=19;~i;--i)
if(dep[fa[x][i]]>=dep[y])
x=fa[x][i];
if(x==y) return x;
for(int i=19;~i;--i)
if(fa[x][i]^fa[y][i])
x=fa[x][i],y=fa[y][i];
return fa[x][0];
}
void chk(line l,int pos){
int x=l.x,y=l.y;
poi sum=l.w+(dis[y]*-1)+dis[x];
if(!sum.chk()){
int lca=Lca(x,y);
++val[x],++val[y],val[lca]-=2;
er.push_back(l);
}
else bo[pos]=1;
}
IL void print(){
sort(ans.begin(),ans.end());
int nn=0;
for(int i=0;i<ans.size();++i)
if(!ban[ans[i]]) ++nn;
printf("%d\n",nn);
for(int i=0;i<ans.size();++i)
if(!ban[ans[i]]) printf("%d ",ans[i]);
putchar('\n');
}
void dfs2(int u,int f){
vis[u]=1;
for(int i=fir[u],v;v=e[i].to;i=e[i].nxt)
if(v^f) id[v]=e[i].id,dfs2(v,u),val[u]+=val[v];
if(!val[u]&&id[u]) ans.push_back(id[u]);
}
void work1(){
for(int i=1;i<=cnt;++i){
int x=re[i].x,y=re[i].y,lca=Lca(x,y);
++val[x],++val[y],val[lca]-=2;
}
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;++i)
if(!vis[i]) dfs2(i,0);
print();
}
void dfs3(int u,int f){
vis[u]=1;
for(int i=fir[u],v;v=e[i].to;i=e[i].nxt)
if(v^f) id[v]=e[i].id,dfs3(v,u),val[u]+=val[v];
if(val[u]==er.size()) ans.push_back(id[u]);
}
void dfs4(int u,int f){
vis[u]=1;
for(int i=fir[u],v;v=e[i].to;i=e[i].nxt)
if(v^f) id[v]=e[i].id,dfs4(v,u),val[u]+=val[v];
if(val[u]) ban[id[u]]=1;
}
void work2(){
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;++i)
if(!vis[i]) dfs3(i,0);
if(er.size()==1) ans.push_back(er[0].id);
memset(val,0,sizeof(val));
for(int i=1;i<=cnt;++i)
if(bo[i]){
int x=re[i].x,y=re[i].y,lca=Lca(x,y);
++val[x],++val[y],val[lca]-=2;
}
memset(vis,0,sizeof(vis));
for(int i=1;i<=n;++i)
if(!vis[i]) dfs4(i,0);
print();
}
void solve(){
int u,v,x,y,z;
n=in(),m=in();
for(int i=1;i<=n;++i) f[i]=i;
for(int i=1;i<=m;++i)
u=in(),v=in(),x=in(),y=in(),z=in(),
l[i]=(line){u,v,i,(poi){x,y,z}};
for(int i=1;i<=m;++i){
int x=l[i].x,y=l[i].y;
if(find(x)^find(y)) f[find(x)]=find(y),add(x,y,l[i].id,l[i].w);
else re[++cnt]=l[i];
}
for(int i=1;i<=n;++i)
if(!vis[i]) dfs1(i,0);
for(int i=1;i<=cnt;++i) chk(re[i],i);
if(!er.size()) work1();
else work2();
}
int main()
{
int T=1;
while(T--) solve();
return 0;
}
E Longest Increasing Subsequence
题意:构造一个长度不超过 100 100 100 的排列,使得其最长上升子序列个数恰好为 m m m 个。 m ≤ 1 × 1 0 9 m \leq 1\times 10^9 m≤1×109。
解法:为了保证 LIS 的个数,一个基础的构造是 2 , 1 , 4 , 3 , 6 , 5 ⋯ , 2 n , 2 n − 1 2,1,4,3,6,5\cdots,2n,2n-1 2,1,4,3,6,5⋯,2n,2n−1,这样可以使得 LIS 的个数为 2 n 2^n 2n。同时此时的 LIS 序列长度为 n n n。最后添加一个最大值,作为全部 LIS 的终止。接下来考虑利用二进制拆分,如何填补更小的 2 i 2^i 2i。
一个可行的操作是,从大到小的考虑 2 i 2^i 2i,从后往前的往初始序列中插入。在第 2 i + 1 2i+1 2i+1 个数字的前面插入一个比 2 n 2n 2n 大的数字,记为 x x x,这样就可以让该数字可以在前面有 2 i 2^i 2i 种选择,同时若选择了新加入的数字,则后面只能选最大值。但是选择到了这里 LIS 的长度不够,所以需要在 x x x 的往后增补一些数字。注意到对于 2 j 2^j 2j 的考虑,一定是在 2 i , i > j 2^i,i>j 2i,i>j 之后考虑的。因而 2 j 2^j 2j 这里的 LIS 长度增补可以利用后面增补的数字,只需要增补到 n n n 的长度即可。因而若 2 i 2^i 2i 这里已经加了 x x x 个数字, 2 j 2^j 2j 这里只需要额外增补 n − j − x n-j-x n−j−x 个数字即可。
例如,考虑 ( 100101 ) 2 (100101)_2 (100101)2,那么首先构造 2 , 1 , 4 , 3 , 6 , 5 , 8 , 7 , 10 , 9 , 12 , 11 2,1,4,3,6,5,8,7,10,9,12,11 2,1,4,3,6,5,8,7,10,9,12,11。首先插入一个最大的: 2 , 1 , 4 , 3 , 6 , 5 , 8 , 7 , 10 , 9 , 12 , 11 , 100 2,1,4,3,6,5,8,7,10,9,12,11,100 2,1,4,3,6,5,8,7,10,9,12,11,100,考虑 2 2 2^2 22,因而在 6 6 6 前面插入一个比最大值小的数字,例如 99 99 99。但是这样取到 99 99 99 LIS 长度不足,因而还需要增补四个数字(为了全部整数因而要将 99 99 99 适当下调为 96 96 96): 2 , 1 , 4 , 3 , ( 96 ‾ , 97 , 98 , 99 ) , 6 , 5 , 8 , 7 , 10 , 9 , 12 , 11 , 100 2,1,4,3,(\underline{96},97,98,99),6,5,8,7,10,9,12,11,100 2,1,4,3,(96,97,98,99),6,5,8,7,10,9,12,11,100。最后的 2 0 2^0 20 需要在序列的开头增补一个数字,同时为了满足 LIS 的长度, 因而需要开头加入两个数字: ( 94 ‾ , 95 ) , 2 , 1 , 4 , 3 , ( 96 ‾ , 97 , 98 , 99 ) , 6 , 5 , 8 , 7 , 10 , 9 , 12 , 11 , 100 (\underline{94},95),2,1,4,3,(\underline{96},97,98,99),6,5,8,7,10,9,12,11,100 (94,95),2,1,4,3,(96,97,98,99),6,5,8,7,10,9,12,11,100。最后再离散化一下就可以得到最终的排列。
这样的排列长度为: 2 × 30 + 30 = 90 2\times 30+30=90 2×30+30=90,满足条件,因为总的添加数字个数仅为 LIS 的长度。
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t, m;
scanf("%d", &t);
while(t--)
{
scanf("%d", &m);
int len = 30;
while (!(m >> len & 1))
len--;
vector<int> add(len, 0);
int cnt = 0;
for (int i = len - 1; i >= 0;i--)
if (m >> i & 1)
{
add[i] = len - i - cnt;
cnt += add[i];
}
printf("%d\n", 2 * len + cnt + 1);
int base = 2 * len;
for (int i = 0; i < len;i++)
{
while (add[i] && add[i]--)
printf("%d ", ++base);
printf("%d %d ", 2 * i + 2, 2 * i + 1);
}
printf("%d\n", 2 * len + cnt + 1);
}
return 0;
}
F Matrix and GCD
题意:给定 n × m n \times m n×m 的矩阵,其中 [ 1 , n m ] [1,nm] [1,nm] 的数字均只出现一次,问所有的连续子矩阵的 $\gcd $ 之和。 n , m ≤ 1 × 1 0 3 n,m \leq 1\times 10^3 n,m≤1×103。
解法:考虑 O ( n log n ) \mathcal O(n \log n) O(nlogn) 的倍数枚举,统计有 f i f_i fi 个连续子矩形其中全部的数字均是 i i i 的倍数,再进行容斥,答案为 ∑ i = 1 n m μ ( i ) f i \displaystyle \sum_{i=1}^{nm} \mu(i)f_i i=1∑nmμ(i)fi。
因而问题转化为, n × m n\times m n×m 的矩形中,有 k k k 个特殊格点,问有几个矩形是完全由特殊格点组成的。首先先 O ( k log k ) \mathcal O(k \log k) O(klogk) 的进行排序,然后 O ( k ) \mathcal O(k) O(k) 的从下往上统计每个点垂直往下有多少个连续的特殊格点,然后横向枚举每个格点,用单调栈在线性时间内计算出以当前格点为左上角有多少个矩形,一次计算一整个横向连续段。因而对于一个连通块只需要 O ( k ) \mathcal O(k) O(k) 的时间,因而总的时间复杂度为 O ( n m log 2 n m ) \mathcal O(nm \log^2 nm) O(nmlog2nm)。
#include <bits/stdc++.h>
#define fp(i, a, b) for (int i = a, i##_ = (b) + 1; i < i##_; ++i)
#define fd(i, a, b) for (int i = a, i##_ = (b) - 1; i > i##_; --i)
using namespace std;
const int N = 1e3 + 5, M = 1e6 + 5;
using ll = int64_t;
int n, m, a[N][N], vis[N][N], H[N][N];
pair<int, int> pos[M];
ll calc(int *h, int k) {//计算矩形个数
stack<int> s;
vector<int> l(k), r(k);
fd(i, k - 1, 0) {
while (!s.empty() && h[i] <= h[s.top()]) l[s.top()] = i, s.pop();
s.push(i);
}
while (!s.empty()) l[s.top()] = -1, s.pop();
fp(i, 0, k - 1) {
while (!s.empty() && h[i] < h[s.top()]) r[s.top()] = i, s.pop();
s.push(i);
}
while (!s.empty()) r[s.top()] = k, s.pop();
ll res = 0;
fp(i, 0, k - 1) res += (ll)h[i] * (i - l[i]) * (r[i] - i);
return res;
}
void Solve() {
scanf("%d%d", &n, &m);
fp(i, 1, n) fp(j, 1, m)
scanf("%d", a[i] + j), pos[a[i][j]] = {i, j};
int k = n * m;
vector<ll> cnt(k + 1);
fp(d, 1, k) {
vector<pair<int, int>> a;
for (int t = d; t <= k; t += d) {
auto [x, y] = pos[t];
vis[x][y] = 1, a.push_back({x, y});
}
sort(a.begin(), a.end());
for (int i = a.size() - 1; ~i; --i) {
auto [x, y] = a[i];
H[x][y] = vis[x + 1][y] ? H[x + 1][y] + 1 : 1;
}
for (int i = 0, j; i < a.size(); i = j + 1) {
for (j = i; j + 1 < a.size() && a[j + 1].first == a[i].first && a[j + 1].second == a[j].second + 1; ++j);
cnt[d] += calc(H[a[i].first] + a[i].second, j - i + 1);
}
for (auto [x, y] : a) vis[x][y] = 0;
}
ll ans = 0;
fd(d, k, 1) {
for (int t = 2 * d; t <= k; t += d)
cnt[d] -= cnt[t];
ans += cnt[d] * d;
}
printf("%lld\n", ans);
}
int main() {
int t = 1;
while (t--) Solve();
return 0;
}
G Magic Spells
题意:给定 k k k 个串 { S i } \{S_i\} {Si},问在每个串中都出现的本质不同回文子串个数。 ∑ ∣ S i ∣ ≤ 3 × 1 0 5 \sum|S_i| \leq 3\times 10^5 ∑∣Si∣≤3×105, k ≤ 5 k \leq 5 k≤5。
解法: k k k 较小,因而可以考虑对每个串都建立一个 PAM,然后同时对 k k k 个 PAM 进行遍历,只向每个 PAM 都能扩展出来的字符出边走。整体时间复杂度 O ( k ∣ S i ∣ ) \mathcal O(k|S_i|) O(k∣Si∣)。
#include <bits/stdc++.h>
using namespace std;
const int N = 300000;
class PAM
{
public:
struct node
{
int ch[26];
int fail;
int len;
int cnt;
node ()
{
memset(ch, 0, sizeof(ch));
fail = len = cnt = 0;
}
} NIL;
vector<node> t;
int tot, len, last;
string s;
int getfail(int x, int place)
{
while (s[place - t[x].len - 1] != s[place])
x = t[x].fail;
return x;
}
PAM()
{
s = " ";
tot = 1;
t.push_back(NIL);
t.push_back(NIL);
t[0].len = 0;
t[0].fail = 1;
t[1].len = -1;
last = 0;
}
int insert(int ch, int ind)
{
s += ch;
int p = getfail(last, ind);
if (!t[p].ch[ch])
{
int q = ++tot;
t.push_back(NIL);
t[q].len = t[p].len + 2;
t[q].fail = t[getfail(t[p].fail, ind)].ch[ch];
t[p].ch[ch] = q;
t[q].cnt = t[t[q].fail].cnt + 1;
}
last = t[p].ch[ch];
return t[last].cnt;
}
} t[5];
string s[5];
long long cnt;
int k;
void dfs(vector<int> p)
{
if(t[0].t[p[0]].len >= 1)
cnt++;
for (int i = 0; i < 26;i++)
{
auto temp = p;
bool flag = 1;
for (int j = 0; j < k;j++)
if (!t[j].t[p[j]].ch[i])
{
flag = 0;
break;
}
if(flag)
{
for (int j = 0; j < k;j++)
temp[j] = t[j].t[p[j]].ch[i];
dfs(temp);
}
}
}
int main()
{
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
cin.tie(NULL);
cout.tie(NULL);
cin >> k;
for (int i = 0; i < k;i++)
{
cin >> s[i];
int ind = 0;
for (auto j : s[i])
t[i].insert(j - 97, ++ind);
}
vector<int> pos1(k, 1), pos0(k, 0);
dfs(pos1);
dfs(pos0);
cout << cnt;
return 0;
}
I The Great Wall II
题意:给定长度为 n n n 的序列 { a i } \{a_i\} {ai},将其划分为连续的 k k k 段,每一段的花费为这一段的最大值,问 k ∈ [ 1 , n ] k \in [1,n] k∈[1,n] 的最小花费。 n ≤ 8 × 1 0 3 n \leq 8\times 10^3 n≤8×103。
解法:考虑 f k , i f_{k,i} fk,i 表示前 i i i 个数字分了 k k k 段的最小花费,那么朴素转移为 f k , i ← min k − 1 ≤ j ≤ i − 1 { f k − 1 , j + max j + 1 ≤ l ≤ i a l } \displaystyle f_{k,i} \leftarrow \min_{k-1\leq j \leq i-1} \{f_{k-1,j}+\max_{j+1 \leq l \leq i}a_l\} fk,i←k−1≤j≤i−1min{fk−1,j+j+1≤l≤imaxal}。考虑分层转移,即固定 k k k,只对 i i i 进行转移,则可以利用单调栈和线段树,维护 f k − 1 , j + max j + 1 ≤ l ≤ i a l \displaystyle f_{k-1,j}+\max_{j+1 \leq l \leq i}{a_l} fk−1,j+j+1≤l≤imaxal 实现 O ( n 2 log n ) \mathcal O(n^2 \log n) O(n2logn)。但是这样很显然还是过不去。
考虑优化掉线段树的 log n \log n logn。由于单调栈中会有弹栈操作,因而可以在弹栈的时候维护出待弹栈部分的 f k − 1 , j f_{k-1,j} fk−1,j 的最小值。对于更前面的最小值,可以在维护单调栈的增减栈操作的时候,同步维护出栈的前缀 f f f 和 f + max f+\max f+max 的最小值。这样就可以实现 O ( n 2 ) \mathcal O(n^2) O(n2)。
#include <bits/stdc++.h>
using namespace std;
const int N = 8000, inf = 0x3f3f3f3f;
int a[N + 5], pre[N + 5], f[N + 5][N + 5];
int main()
{
memset(f, 0x3f, sizeof(f));
int n;
scanf("%d", &n);
for (int i = 1; i <= n;i++)
{
scanf("%d", &a[i]);
f[i][1] = pre[i] = max(pre[i - 1], a[i]);
}
for (int k = 2; k <= n; ++k)
{
vector<int> st, minf, minall;
st.push_back(inf);
minf.push_back(0);
minall.push_back(inf);
for (int i = 1; i <= n; i++)
{
int now = f[i - 1][k - 1];
while (!st.empty() && st.back() <= a[i])
{
now = min(now, minf.back());
minf.pop_back();
minall.pop_back();
st.pop_back();
}
f[i][k] = min(now + a[i], minall.back());
st.push_back(a[i]);
minf.push_back(now);
minall.push_back(min(now + a[i], minall.back()));
}
}
for (int i = 1; i <= n; i++)
printf("%d\n", f[n][i]);
return 0;
}
K NIO’s OAuth2 Server
题意:有 k k k 个元素和 n n n 个由这 k k k 个元素构成的集合 { S n } \{S_n\} {Sn},问由这 k k k 个元素生成的全部 2 k − 1 2^k-1 2k−1 个非空集合中有多少个 T T T 集合满足 T ⊆ ⋃ k = 1 i S k \displaystyle T \subseteq \bigcup_{k=1}^i S_k T⊆k=1⋃iSk,即由 i i i 个集合能覆盖 T T T 集合,对于 i ∈ [ 1 , k ] i \in [1,k] i∈[1,k] 计算答案。 k ≤ 20 k \leq 20 k≤20, n ≤ 1 × 1 0 5 n \leq 1\times 10^5 n≤1×105。
解法:首先利用状压将显然所用集合个数不会超过 k k k 个,因而可以枚举进行 i i i 次集合并操作,能得到的集合个数。
这样问题转化为,对这 n n n 个集合进行 i i i 次任意并操作,能得到哪些集合。那么利用集合幂级数,使用 f ( x ) = ∑ i = 0 2 k − 1 f i x i \displaystyle f(x)=\sum_{i=0}^{2^k-1}f_ix^i f(x)=i=0∑2k−1fixi,其中 f i f_i fi 为合成集合 i i i 的方案,进行 i i i 次 FWTor 即可。最后统计答案的时候,只需要统计系数(方案数)是否为 0 0 0,若 f i f_i fi 不为 0 0 0 则表示可以合成,同时对于后面的计算需要强制令 f i = 1 f_i=1 fi=1 否则最后的方案数可能过大导致溢出。
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
using Poly = vector<long long>;
void FWTor(Poly &a, bool rev)
{
int n = a.size();
for (int l = 2, m = 1; l <= n; l <<= 1, m <<= 1)
for (int j = 0; j < n; j += l)
for (int i = 0; i < m; i++)
if (!rev)
a[i + j + m] += a[i + j];
else
a[i + j + m] -= a[i + j];
}
Poly operator |(Poly a, Poly b)
{
int n = a.size();
FWTor(a, 0), FWTor(b, 0);
for (int i = 0; i < n; i++)
a[i] *= b[i];
FWTor(a, 1);
return a;
}
int ans[1 << N], cnt[N + 1];
int main()
{
int n, k, x, z;
scanf("%d%d", &n, &k);
Poly base(1 << k, 0), f(1 << k, 0);
f[0] = 1;
while(n--)
{
int y = 0;
scanf("%d", &x);
while(x--)
{
scanf("%d", &z);
y |= 1 << (z - 1);
}
base[y] = 1;
}
for (int i = 0; i < k; i++)
for (int j = (1 << k) - 1; j >= 0; j--)
if (!(j & (1 << i)))
base[j] += base[j ^ (1 << i)];
for (int i = 0; i < 1 << k;i++)
if(base[i])
{
base[i] = ans[i] = 1;
if (i)
cnt[1]++;
}
for (int j = 1; j <= k; j++)
{
f = f | base;
for (int i = 1; i < 1 << k; i++)
if (f[i] && !ans[i])
{
ans[i] = j;
cnt[j]++;
}
for (auto &i : f)
if (i)
i = 1;
}
for (int i = 1; i <= k;i++)
printf("%d ", cnt[i]);
return 0;
}