@1 UOJ91 & UOJ418 & UOJ94
[集训队互测2015] 最大异或和
题目描述
解法
只要维护线性基就可以很好地回答询问，有一个关键的 \(\tt observation\) 是：维护原序列的线性基等价于维护差分序列的线性基。这样操作一反映到线性基上变成了两个单点修改，操作二变成了两个单点修改加上区间清零，用势能法即可说明总修改次数是 \(O(n)\) 的。
这题肯定要用 bitset 优化，那么问题变成了如何在 \(O(\frac{n^2}{w})\) 删除和插入一个元素。
其实写个带删除线性基就行了，但是我以前没有听说过这东西，所以简单讲解一下它的思路。对于每个数我们需要额外维护它被哪些数字所表示（也就是在线性基构建过程中异或上了那些数），假设现在要删除 \(x\)：
- 如果 \(x\) 不在线性基中，直接删除。
- 否则找到一个不在线性基中，且可以被 \(x\) 表示的数 \(y\)，那么 \(y\) 是可以替换 \(x\) 的，此时线性基的大小不变。那么我们把所有被 \(x\) 表示的数异或上 \(y\) 的被表示集合，就可以达到删除 \(x\) 的效果。
- 若不存在这样的 \(y\)，则线性基的大小必须减少。我们找到最小的可以被 \(x\) 表示的数字 \(z\)，那么删除 \(x\) 之后 \(z\) 这个基必定消除，此后由 \(z\) 来顶替 \(x\) 的位置。所以我们把所有被 \(x\) 表示的数异或上 \(z\)，由于 \(z\) 最小所以线性基大小恰好减一
时间复杂度 \(O(\frac{n^3}{w})\)（\(n,m,q\) 视作同阶），在下面的代码实现中，新建两个 bitset \(c[x],v[x]\) 分别表示数字 \(x\) 插入线性基后的结果，和数字 \(x\) 被哪些数字所表示，上述删除的过程可以简化成十分简洁的代码。
#include <cstdio>
#include <bitset>
#include <iostream>
using namespace std;
const int M = 2005;
#define bs bitset<M>
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,m,q,p[M];bs w,a[M],c[M],v[M];
void ins(int x)
{
for(int i=m-1;i>=0;i--) if(c[x][i])
{
if(p[i]) c[x]^=c[p[i]],v[x]^=v[p[i]];
else {p[i]=x;break;}
}
}
void upd(int x,bs b)// x xor b
{
if(x>n || b.none()) return ;
int o=0;
for(int i=1;i<=n;i++)//find y
if(c[i].none() && v[i][x]) {o=i;break;}
if(!o) for(int i=0;i<m;i++)//find z
if(p[i] && v[p[i]][x]) {o=p[i];p[i]=0;break;}
for(int i=1;i<=n;i++)// combine nothing / y / z
if(i!=o && v[i][x]) v[i]^=v[o],c[i]^=c[o];
c[o]^=b;ins(o);
}
signed main()
{
ios::sync_with_stdio(0);cin.tie(0);
cin>>n>>m>>q;
for(int i=1;i<=n;i++)
cin>>a[i],c[i]=a[i-1]^a[i],v[i][i]=1,ins(i);
while(q--)
{
int op=0,l=0,r=0;cin>>op;
if(op==3)
{
w.reset();
for(int i=m-1;i>=0;i--)
{
if(!w[i] && p[i]) w^=c[p[i]];
cout<<w[i];
}
cout<<endl;continue;
}
cin>>l>>r>>w;
if(op==1)
{
upd(l,w);upd(r+1,w);
for(int i=l;i<=r;i++) a[i]^=w;
}
if(op==2)
{
upd(l,a[l]^w);upd(r+1,a[r]^w);
for(int i=l+1;i<=r;i++) upd(i,a[i]^a[i-1]);
for(int i=l;i<=r;i++) a[i]=w;
}
}
}
[集训队作业2018] 三角形
题目描述
解法
超级好题啊！（我还被自己的错误想法困扰了好久😭
首先考虑计算 \(1\) 的答案，一个关键的 \(\tt observation\) 是：当我们放置 \(w_i\) 后，会立刻回收所有儿子的 \(w_v\)；根据这个观察，我们可以把问题转化到序列上，每次往序列后加入一个点 \(i\)，要求加入 \(i\) 时它的儿子 \(v\) 都已经被加入，然后会发生这样的事情：
- 现有的石子数 \(sum\) 增加 \(w_i\) 的石子数。
- 现有的石子数 \(sum\) 减少 \(\sum w_v\) 的石子数。
那么需要的石子数 \(mx\) 就是 \(sum\) 的历史最大值，可以用一个二元组 \((sum,mx)\) 来描述。点 \(i\) 的二元组是 \((w_i-\sum w_v,w_i)\)，操作的过程可以描述为二元组的合并，我们这样合并两个二元组 \((a_1,b_1)\) 和 \((a_2,b_2)\)：
如果不考虑儿子的限制，那么可以用简单的排序贪心解决。即对于两个二元组 \(x,y\)，如果 (x+y).mx<(y+x).mx，那么就把 \(x\) 放前面。排序之后的顺序就是操作顺序，并且不难证明不会出现形如 \(A<B,B<C,C<A\) 无法排序的情况。
但是儿子的限制还是难以考虑，我们反转操作序列，把限制转化成父亲的限制。具体来说就是逆序进行原来的操作序列，那么加入一个点 \(i\) 时需要满足它的父亲已经被加入，由于逆序会发生这样的事情：
- 现有的石子数 \(sum\) 增加 \(\sum w_v\) 的石子数。
- 现有的石子数 \(sum\) 减少 \(w_i\) 的石子数。
那么点 \(i\) 的二元组就变成了 \((\sum w_v-w_i,\sum w_v)\)，受到逆序的影响，合并规则还是不变。
逆序的正确性来自于，逆序的每个操作后缀，对应着正序的每个操作前缀的操作效果。
现在得到了一个经典问题，我们可以找到优先级最高的点 \(x\)，如果 \(x\) 的父亲已经被加入，那么直接加入 \(x\)；否则在 \(x\) 的父亲被加入时 \(x\) 会立刻被加入，这构成了一个依赖关系，把 \(x\) 和它的父亲合并即可。
现在解决了 \(1\) 的问题，对于每个子树，由于操作顺序不会改变，所以可以预处理出操作顺序。然后以操作顺序建立一棵线段树，通过线段树合并得到每个子树的线段树，就可以算出答案，时间复杂度 \(O(n\log n)\)
总结
限制对象的切换十分巧妙，本来是各种各样的儿子，并不好考虑限制；但是切换之后变成了单一的父亲，可以套用经典模型。
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <set>
using namespace std;
const int M = 200005;
#define ll long long
#define pb push_back
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,m,rt[M],w[M],p[M],fa[M],vis[M],b[M];
vector<int> g[M],vc[M];ll ans[M],w2[M];
struct node
{
ll x,y;int id;
node(ll X=0,ll Y=0,int I=0) : x(X) , y(Y) , id(I) {}
node operator + (const node &b) const
{return node(x+b.x,max(y,x+b.y),id);}
bool operator < (const node &b) const
{
ll t1=(*this+b).y,t2=(b+*this).y;
if(t1!=t2) return t1<t2;
if(x!=b.x) return x<b.x;
if(y!=b.y) return y<b.y;
return id<b.id;
}
}a[M];set<node> h;
node s[M*30];int cnt,ls[M*30],rs[M*30];
int find(int x)
{
if(x!=fa[x]) fa[x]=find(fa[x]);
return fa[x];
}
void dfs(int u)
{
vis[u]=1;b[u]=++m;
for(int v:vc[u]) dfs(v);
}
void ins(int &x,int l,int r,int p)
{
if(!x) x=++cnt;
if(l==r) {s[x]=a[l];return ;}
int mid=(l+r)>>1;
if(mid>=p) ins(ls[x],l,mid,p);
else ins(rs[x],mid+1,r,p);
s[x]=s[ls[x]]+s[rs[x]];
}
int merge(int x,int y)
{
if(!x || !y) return x+y;
ls[x]=merge(ls[x],ls[y]);
rs[x]=merge(rs[x],rs[y]);
s[x]=s[ls[x]]+s[rs[x]];
return x;
}
void work(int u)
{
ins(rt[u],1,n,b[u]);
for(int v:g[u])
work(v),rt[u]=merge(rt[u],rt[v]);
ans[u]=s[rt[u]].y;
}
signed main()
{
read();n=read();
for(int i=2;i<=n;i++)
p[i]=read(),g[p[i]].pb(i);
for(int i=1;i<=n;i++)
w[i]=read(),w2[p[i]]+=w[i],fa[i]=i;
for(int i=1;i<=n;i++)
a[i]=node(w2[i]-w[i],w2[i],i),h.insert(a[i]);
for(int T=1;T<=n;T++)
{
int x=h.begin()->id;
h.erase(h.begin());
if(x==1 || vis[p[x]]) dfs(x);
else
{
int u=find(p[x]);
h.erase(a[u]);
a[u]=a[u]+a[x];
h.insert(a[u]);
vc[u].pb(x);fa[x]=u;
}
}
for(int i=1;i<=n;i++)//get the order
a[b[i]]=node(w2[i]-w[i],w2[i],i);
work(1);
for(int i=1;i<=n;i++)
printf("%lld ",ans[i]+w[i]);
}
[集训队互测2015] 胡策的统计
题目描述
解法
首先讲解一下 \(dp\) 的方法，像我这样生成函数完全不会的选手就指望这个骗点分了。
设 \(f(S)\) 表示考虑集合 \(S\) 的导出子图，其中有多少个生成子图是连通图，转移正难则反，设 \(m(S)\) 表示集合 \(S\) 导出子图的边数，注意我们需要强制一个点在集合 \(T\) 中才能不算重（虽然这是老生常谈了）：
设 \(g(S)\) 表示集合 \(S\) 的连通值之和，把生成子图和计算连通值混合计数，也就是数出原图的连通块有多少种排列方式，那么枚举排在最前面的连通块即可：
那么时间复杂度 \(O(3^n)\)，可以获得 \(60\) 分的高分。
导出子图的连通生成子图计数是经典问题，在我这篇古老的 集合幂级数和状压dp 有讲解，但还是再梳理下思路。
（所以下文只是梳理思路，详细讲解可以看我给的那篇博客）
考虑加速求解 \(f(S)\)，设 \(h(S)=2^{m(S)}(S\not=\varnothing)\)，把它们都看成集合幂级数，可以列出下面的等式：
对于第一个等号，左边的含义是导出子图的生成子图个数；右边的含义是，用若干个连通块拼出了生成子图，但是由于连通块之间有顺序，所以要除去 \(k!\)；继续变形这个式子：
那么问题变成了快速求 \(f=\ln(1+h)\)，我们先把集合幂级数通过莫比乌斯正变换转化成集合占位幂级数，然后对于每个集合 \(S\)，可以获得一个 \(n\) 次多项式，用形式幂级数的方式对它求 \(\ln\) 即可。
对于形式幂级数求 \(a=\ln(1+b)\) 的问题，求导之后就可以获得递推式，这一部分时间复杂度 \(O(n^22^n)\)
知道 \(f(S)\) 之后求 \(g(S)\) 就是普通的子集卷积，这一部分复杂度也是 \(O(n^22^n)\)
总时间复杂度 \(O(n^22^n)\)
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
const int M = (1<<20)+5;
const int MOD = 998244353;
#define ll long long
int read()
{
int x=0,f=1;char c;
while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
return x*f;
}
int n,m,f[22][M],g[22][M],b[M];
int pw[500],inv[500],x[500],y[500];
void fwt(int *a,int n,int op)
{
for(int i=1;i<n;i<<=1)
for(int j=0;j<n;j+=i<<1)
for(int k=0;k<i;k++)
{
if(op==1) a[i+j+k]=(a[i+j+k]+a[j+k])%MOD;
else a[i+j+k]=(a[i+j+k]-a[j+k]+MOD)%MOD;
}
}
signed main()
{
n=read();m=read();inv[0]=inv[1]=pw[0]=1;
for(int i=1;i<=m;i++) pw[i]=2ll*pw[i-1]%MOD;
for(int i=2;i<=n;i++)
inv[i]=(ll)inv[MOD%i]*(MOD-MOD/i)%MOD;
for(int i=1;i<=m;i++)
x[i]=read()-1,y[i]=read()-1;
for(int s=0;s<(1<<n);s++)
{
int t=0;b[s]=b[s>>1]+(s&1);
for(int i=1;i<=m;i++)
t+=((s>>x[i]&1) && (s>>y[i]&1));
f[b[s]][s]=pw[t];
}
for(int i=1;i<=n;i++) fwt(f[i],1<<n,1);
// get ln
for(int i=1;i<=n;i++)
{
for(int k=0;k<i;k++)
for(int j=0;j<1<<n;j++)
g[i][j]=(g[i][j]+(ll)k*g[k][j]%MOD*f[i-k][j])%MOD;
for(int j=0;j<1<<n;j++)
g[i][j]=(f[i][j]-(ll)inv[i]*g[i][j]%MOD+MOD)%MOD;
}
//
memset(f,0,sizeof f);
for(int i=0;i<1<<n;i++) f[0][i]=1;
for(int i=1;i<=n;i++)
for(int k=0;k<i;k++)
for(int j=0;j<1<<n;j++)
f[i][j]=(f[i][j]+(ll)f[k][j]*g[i-k][j])%MOD;
fwt(f[n],1<<n,-1);
printf("%lld\n",f[n][(1<<n)-1]);
}
