[SDOI2017]切树游戏

最新推荐文章于 2021-09-28 18:33:30 发布
最新推荐文章于 2021-09-28 18:33:30 发布
阅读量220 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/yicongli/p/10438052.html
版权

题面

这道题从昨天下午写到今天下午

我好菜啊

感到绝望

算法一

考虑朴素dp

设\(dp[x][i]\)表示以\(x\)为根的子树中权值\(i\)的子树个数

考虑加入子节点\(y\)的转移
\[ dp[x][k]+=\sum_{i~xor~j=k}{dp[x][i]*dp[y][j]} \]
答案即为
\[ \sum_{i=1}^{n}{dp[i][k]} \]
复杂度\(O(QNM^2)\)

算法二

注意到可以使用FWT优化

设\(DP[x]\)表示\(FWT(dp[x])\)
\[ DP[x]+=DP[x]*DP[y] \]
即
\[ DP[x]*=DP[y]+1 \]
注意因为已经\(FWT\)过了

所以这里的乘法是按位相乘

所以那个\(1\)指的是一个全\(1\)的数组

定义Poly类记录\(128\)个位置的\(dp\)值

FWT后计算

最后IFWT回来

复杂度\(O(QNMlogM)\)

算法三

发现这是个动态DP

设\(dfn[x]\)表示\(x\)的\(dfs\)序

\(F[dfn[x]]\)表示\(x\)的DP值

即
\[ F[dfn[x]]=\prod_{y~is ~son~of~x}{(F[dfn[y]]+1)} \]
\(f[dfn[x]]\)表示\(x\)轻儿子的DP值

即
\[ f[dfn[x]]=\prod_{y~is~light~son~of~x}{(F[dfn[y]]+1)} \]
\(G[dfn[x]]\)表示\(x\)子树内的答案

即
\[ G[dfn[x]]=\sum_{y~is~son~of~x}G[dfn[y]] \]
\(g[dfn[x]]\)表示\(x\)轻子树内的答案

即
\[ g[dfn[x]]=\sum_{y~is~light~son~of~x}{G[dfn[y]]} \]
注意以上数组经过FWT后计算

设\(y​\)是\(x​\)的重儿子

有转移
\[ F[dfn[x]]=f[dfn[x]]*(F[dfn[y]]+1)\\ G[dfn[x]]=g[dfn[x]]+F[dfn[x]]+G[dfn[y]] \]
设\(dfn[x]=i\)那么\(dfn[y]=i+1\)

有
\[ F[i]=f[i]*F[i+1]+f[i]\\ G[i]=g[i]+f[i]*F[i+1]+f[i]+G[i+1]\\ \]
写成矩阵就是
\[ \left[ \begin{matrix} F_{i+1}&G_{i+1}&1 \end{matrix} \right] * \left[ \begin{matrix} f_i&f_i&0\\ 0&1&0\\ f_i&f_i+g_i&1 \end{matrix} \right] =\left[ \begin{matrix} F_{i}&G_{i}&1 \end{matrix} \right] \]
考虑合并矩阵
\[ \left[ \begin{matrix} a&b&0\\ 0&1&0\\ c&d&1 \end{matrix} \right]* \left[ \begin{matrix} A&B&0\\ 0&1&0\\ C&D&1 \end{matrix} \right] = \left[ \begin{matrix} aA&aB+b&0\\ 0&1&0\\ cA+C&cB+d+D&1 \end{matrix} \right] \]
发现只需记录\(4\)个位置的值即可

定义Info类记录矩阵

动态DP

复杂度\(QMlog^2N\)

可以通过

考虑细节

细节一

修改\(x\)的时候\(f[dfn[fa[x]]]\)需要除去原来的贡献

因为是在\(\mod 10007\)意义下求解

所以需要求出逆元

然而\(0\)(\(10007\)的倍数)没有逆元

似乎有一种记录\(0\)个数的做法

但是更自然的想法是对每个节点维护一颗线段树专门维护\(f​\)数组

维护像这种不可减的信息都是这样用数据结构维护的

比如最值可以用multiset维护

所以直接修改线段树即可

并不会成为复杂度瓶颈

但是因为每个点都要开

所以必须动态开点

细节二

最后统计答案乘上初始矩阵\(\left[\begin{matrix}0&0&1 \end{matrix} \right]​\)

直接取出答案就行了

不需要实现矩阵乘法

这是套路
\[ \left[\begin{matrix}0&0&1 \end{matrix} \right]* \left[ \begin{matrix} a&b&0\\ 0&1&0\\ c&d&1 \end{matrix} \right] =\left[\begin{matrix}c&d&1 \end{matrix} \right] \]
细节三

因为是从下往上的dp

也就是线段树是反着维护矩阵的

这是套路

#include<bits/stdc++.h>

using namespace std;

#define gc c=getchar()
#define r(x) read(x)
#define ll long long

template<typename T>
inline void read(T&x){
    x=0;T k=1;char gc;
    while(!isdigit(c)){if(c=='-')k=-1;gc;}
    while(isdigit(c)){x=x*10+c-'0';gc;}x*=k;
}

const int N=3e4+7;
const int M=128|7;
const int p=10007;

inline int add(int a,int b){
    return (a+=b)>=p?a-p:a;
}

inline int sub(int a,int b){
    return (a-=b)<0?a+p:a;
}

inline int qpow(int a,int b){
    int ans=1;
    while(b){
        if(b&1)(ans*=a)%=p;
        (a*=a)%=p;
        b>>=1;
    }
    return ans;
}

int n,m;
int Inv;

struct Poly{
    
    int A[M];
    
    inline void FWT(){
        for(int i=1;i<m;i<<=1){
            for(int j=0;j<m;j+=(i<<1)){
                for(int k=0;k<i;++k){
                    int u=A[j+k],v=A[i+j+k];
                    A[j+k]=add(u,v),A[i+j+k]=sub(u,v);
                }
            }
        }
    }
    
    inline void IFWT(){
        FWT();
        for(int i=0;i<m;++i){(A[i]*=Inv)%=p;}
    }
    
    inline Poly(){}
    
    inline Poly(int x){
        memset(A,0,m<<2);
        A[x]=1;
        FWT();
    }
    
    inline int& operator [] (const int &x){return A[x];}
    
    inline const int& operator [] (const int &x)const {return A[x];}
    
    inline void operator =(const Poly &T){
        memcpy(A,T.A,m<<2);
    }
    
    inline void operator *= (const Poly &T){
        for(int i=0;i<m;++i)(A[i]*=T[i])%=p;
    }
    
    inline Poly operator * (const Poly &T)const {
        Poly ret;
        for(int i=0;i<m;++i)ret[i]=A[i]*T[i]%p;
        return ret;
    }
    
    inline void operator += (const Poly &T){
        for(int i=0;i<m;++i)A[i]=add(A[i],T[i]);
    }
    
    inline Poly operator +(const Poly &T)const {
        Poly ret;
        for(int i=0;i<m;++i)ret[i]=add(A[i],T[i]);
        return ret;
    }
    
    inline void operator -= (const Poly &T){
        for(int i=0;i<m;++i)A[i]=sub(A[i],T[i]);
    }
    
    inline Poly operator -(const Poly &T)const {
        Poly ret;
        for(int i=0;i<m;++i)ret[i]=sub(A[i],T[i]);
        return ret;
    }
}one,F[N],G[N],g[N];

int root[N];
int cnt[N];

namespace Data{
    int tot;
    Poly tr[N*10];
    int ls[N*10];
    int rs[N*10];
    int siz[N*10];
    #define ls ls[rt]
    #define rs rs[rt]
    
    inline void update(int rt){
        tr[rt]=tr[ls]*tr[rs];
    }
    
    void insert(int &rt,int l,int r,int x,const Poly &v){
        if(!rt)rt=++tot;
        ++siz[rt];
        if(l==r)return void(tr[rt]=v);
        int mid=(l+r)>>1;
        if(x<=mid)insert(ls,l,mid,x,v);
        else insert(rs,mid+1,r,x,v);
        if(siz[rt]>r-l)update(rt);
    }
    #undef ls
    #undef rs
};

int a[N];

vector<int>E[N];

int fa[N],siz[N],dep[N],son[N];

void dfs1(int x,int f){
    fa[x]=f;
    siz[x]=1;
    dep[x]=dep[f]+1;
    for(int i=0;i<E[x].size();++i){
        int v=E[x][i];
        if(v==f)continue;
        dfs1(v,x);
        siz[x]+=siz[v];
        if(siz[son[x]]<siz[v])son[x]=v;
    }
}

int dfs_clock;
int top[N],bot[N],dfn[N],ptn[N];

void dfs2(int x,int t){
    top[x]=t;
    dfn[x]=++dfs_clock;
    ptn[dfs_clock]=x;
    if(!son[x])return void(bot[x]=x);
    dfs2(son[x],t);
    bot[x]=bot[son[x]];
    for(int i=0;i<E[x].size();++i){
        int v=E[x][i];
        if(v==fa[x]||v==son[x])continue;
        dfs2(v,v);
    }
}

int pos[N];

void dfs3(int x){
    F[x]=Poly(a[x]);
    for(int i=0;i<E[x].size();++i){
        int v=E[x][i];
        if(v==fa[x])continue;
        dfs3(v);
        F[x]*=F[v]+one;
        G[x]+=G[v];
    }
    G[x]+=F[x];
    for(int i=0;i<E[x].size();++i){
        int v=E[x][i];
        if(v==fa[x]||v==son[x])continue;
        pos[v]=++cnt[x];
    }
    cnt[x]++;
    Data::insert(root[x],1,cnt[x],cnt[x],Poly(a[x]));
    for(int i=0;i<E[x].size();++i){
        int v=E[x][i];
        if(v==fa[x]||v==son[x])continue;
        g[x]+=G[v];
        Data::insert(root[x],1,cnt[x],pos[v],F[v]+one);
    }
}

struct Info{
    Poly a,b,c,d;
    
    inline Info(){};
    inline Info(const Poly &f,const Poly &g):a(f),b(f),c(f),d(f+g){};
    inline Info(const Poly &A,const Poly &B,const Poly &C,const Poly &D):a(A),b(B),c(C),d(D){}
    
    inline Info operator + (const Info &x){
        return Info(a*x.a,a*x.b+b,c*x.a+x.c,c*x.b+d+x.d);
    }
    
    inline Poly f(){
        return c;
    }
    
    inline Poly g(){
        return d;
    }
    
}tr[N<<2];

#define ls (rt<<1)
#define rs (rt<<1|1)

inline void update(int rt){
    tr[rt]=tr[rs]+tr[ls];
}

void build(int rt,int l,int r){
    if(l==r){
        int x=ptn[l];
        tr[rt]=Info(Data::tr[root[x]],g[x]);
        return ;
    }
    int mid=(l+r)>>1;
    build(ls,l,mid);
    build(rs,mid+1,r);
    update(rt);
}

void modify(int rt,int l,int r,int x,const Info &v){
    if(l==r){
        tr[rt]=v;
        return ;
    }
    int mid=(l+r)>>1;
    if(x<=mid)modify(ls,l,mid,x,v);
    else modify(rs,mid+1,r,x,v);
    update(rt);
}

Info query(int rt,int l,int r,int x,int y){
    if(x<=l&&r<=y)return tr[rt];
    int mid=(l+r)>>1;
    if(y<=mid)return query(ls,l,mid,x,y);
    if(x>mid)return query(rs,mid+1,r,x,y);
    return query(rs,mid+1,r,x,y)+query(ls,l,mid,x,y);
}

inline void Change(int x,int y){
    a[x]=y;
    Data::insert(root[x],1,cnt[x],cnt[x],Poly(a[x]));
    while(x){
        modify(1,1,n,dfn[x],Info(Data::tr[root[x]],g[x]));
        x=top[x];
        Info tmp=query(1,1,n,dfn[x],dfn[bot[x]]);
        if(fa[x])Data::insert(root[fa[x]],1,cnt[fa[x]],pos[x],Poly(tmp.f()+one));
        if(fa[x])g[fa[x]]-=G[x];
        G[x]=tmp.g();
        if(fa[x])g[fa[x]]+=G[x];
        x=fa[x];
    }
}

inline int Query(int x){
    Poly t=query(1,1,n,dfn[1],dfn[bot[1]]).g();
    t.IFWT();
    return t[x];
}

inline void init(){
    r(n),r(m);Inv=qpow(m,p-2);
    for(int i=0;i<m;++i)one[i]=1;
    for(int i=1;i<=n;++i){
        r(a[i]);
    }
    for(int i=1;i<n;++i){
        int u,v;r(u),r(v);
        E[u].push_back(v);
        E[v].push_back(u);
    }
    dfs1(1,0);
    dfs2(1,1);
    dfs3(1);
    build(1,1,n);
}

int main(){
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    init();
    int q;r(q);
    while(q--){
        char s[10];
        scanf("%s",s);
        if(s[0]=='C'){
            int x,y;r(x),r(y);
            Change(x,y);
        }
        else {
            int k;r(k);
            printf("%d\n",Query(k));
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/yicongli/p/10438052.html

weixin_30258901
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
[SDOI2017]切树游戏 (全局平衡二叉树维护动态DP)
Freopen的博客
04-04 307
基于变换合并的树上动态 DP 的链分治算法 & SDOI2017 切树游戏（cut）解题报告 切了一晚树心态崩了。 你问我怎么求异或逆卷积。 我，我。我？？？我！！！！！才不会说是把FWT后的数组每个求个逆元呢。。。。。。。 怎么模数为质数还有没有逆元的操作啊！！！！！ AC Code: #include<bits/stdc++.h> #define maxn 30005 #d...
「SDOI2017」文本校正
Freopen的博客
07-08 567
题目 分类讨论六种排列： ABC：ABC：ABC：一次哈希判断。 CAB：CAB：CAB：枚举CCC的长度，总共nnn次哈希判断。 BCA：BCA：BCA：枚举AAA的长度，总共nnn次哈希判断。 CBA：CBA：CBA：构造新串P=s1tns2tn−1...snt1P = s_1t_ns_2t_{n-1}...s_nt_1P=s1​tn​s2​tn−1​...sn​t1​ 那么问题转化为将PPP划分为333个偶回文串。 枚举第一个回文串的位置[1....2x][1....2x][1....2x]，那么就
SDOI2017 切树游戏
aoye9670的博客
01-04 163
猫老师的基于变换合并的树上动态DP的链分治算法&SDOI2017切树游戏(cut)解题报告中的例题 一道神仙题. 参考了这位大佬的\(Blog\),大家快去%他 注意:此篇文章的约定: \(s_u\)表示节点\(u\)的子节点集合. \(ls_u\)表示节点\(u\)的轻儿子集合. 这个轻儿子指树剖之后的. 我们先列出简单\(dp\)方程. \(f[u][i]\)表示以\(u...
[ DP FWT 链分治 ] [ SDOI2017 ] BZOJ4911 切树游戏
gjghfd
05-17 497
题解 #include&lt;bits/stdc++.h&gt; using namespace std; char nc() { static char buf[100000],*p1=buf,*p2=buf; return p1==p2&amp;&amp;(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++; }...
[FWT && 链分治] BZOJ4911.[Sdoi2017]切树游戏
CE玩家
09-27 1167
可以看immortalCO大佬的博客我是参考了Manchery的代码…#include <cstdio> #include <iostream> #include <algorithm> #include <vector>using namespace std;const int N=30010,M=310,P=10007,inv2=P+1>>1;inline char nc(){ stat
SDOI2017 切树游戏（FWT+树链剖分+dp）
WAautomaton的博客
02-12 387
题目链接 题目大意 维护一棵树，支持： 1.动态修改某个点权值； 2.查询有多少个联通子树异或值为ppp。 题解 这题感觉比较套路，显然可以列出一个dp方程，发现这是FWT异或卷积的形式。具体的，记f[i]f[i]f[i]为iii的dp数组的FWT卷积，那么f[i]=b[val[i]]∗∏v∈son[i](f[v]+b[0])f[i]=b[val[i]]*\prod_{v\in son[i]} (...
sdoi2017R1D2
04-16
标题 "sdoi2017R1D2" 暗示这可能是一个与编程竞赛或算法挑战相关的项目，可能是2017年某个阶段的比赛数据。"sdoi" 可能代表 "Sphere Online Judge" 或类似的在线评判系统，这是一个用于举办编程比赛的平台。"R1D2" ...
sdoi2017R1D1
04-16
标题 "sdoi2017R1D1" 暗示这可能是一个与软件开发或信息技术竞赛相关的项目，可能是2017年某个阶段的第一天挑战或任务。"sdoi" 可能是 "Software Development Online Invitation" 的缩写，意味着这是一个在线编程或...
SDOI2017 文本校正
g21wcr的博客
11-01 664
传送门 分为6种情况。 ABC:ABC:ABC:哈希O(1)O(1)O(1)判断 CAB:CAB:CAB:枚举CCC的位置，哈希判断ABABAB，O(n)O(n)O(n) BCA:BCA:BCA:枚举AAA的位置，哈希判断BCBCBC，O(n)O(n)O(n) CBA:CBA:CBA:金策字符串算法选讲 如果s=abs=abs=ab，a,ba,ba,b都是回文串，称sss为一个双回文串。 引理：如...
「SDOI2017」切树游戏
Johnny817的博客
01-31 198
题目描述 小 Q 是一个热爱学习的人，他经常去维基百科学习计算机科学。 就在刚才，小 Q 认真地学习了一系列位运算符，其中按位异或的运算符 ⊕\oplus⊕ 对他影响很大。按位异或的运算符是双目运算符。按位异或具有交换律，即 i⊕j=j⊕ii \oplus j = j \oplus ii⊕j=j⊕i。 他发现，按位异或可以理解成被运算的数字的二进制位对应位如果相同，则结果的该位置为 000，否则为...
[链分治][FWT][树链剖分] BZOJ 4911: [Sdoi2017]切树游戏
Vectorxj的博客
12-15 499
SolutionSolutionDP是一个异或卷积的形式，可以FWT把O(128)O(128)的复杂度降下来。 链分治参考immortalCO的博客。 最后还是有些地方00的逆元的问题搞错了。。#include <bits/stdc++.h> using namespace std;const int N = 60303; const int M = 130; const int MOD = 1
[链分治 重链剖分 FWT] BZOJ 4911 [Sdoi2017]切树游戏
雯舞
06-09 2053
我链分治是从immortalCO今年论文学来的 就是一个序列上能够维护的东西，把他搬到重链上，先处理好儿子重链的答案，然后把对这条重链上的影响累加在这条重链上然后就是套路 FWT一下就能加和乘了 注意0没有逆元复杂度O(mnlog2n)O(mn\log^2n) 实际上树链剖分是跑不满的 rank1 开心 O(∩_∩)O~~#include<cstdio> #include<cstdlib> #
BZOJ4911: [Sdoi2017]切树游戏
weixin_34099526的博客
03-14 101
BZOJ 4911 切树游戏 重构了三次.jpg 每次都把这个问题想简单了.jpg 果然我还是太菜了.jpg 这种题的题解可以一眼秒掉了，FWT+动态DP简直是裸的一批... 那么接下来，考虑如何维护信息。 每个点维护$4$个信息，分别表示，这条链自底向上，自上向底，两端都在这条链的轻儿子里，和两端为链头的方案数。 这样的话，正常询问就没啥问题了，只需要每次修改和初始化的时候FWT一下，然后最后F...
LOJ #2269. 「SDOI2017」切树游戏 题解
莫莫 dicol 的博客
09-28 317
LOJ #2269. 「SDOI2017」切树游戏 #2269. 「SDOI2017」切树游戏 没错我在某谷被卡掉了，之后会了全局平衡二叉树再更新那个做法。 不考虑修改怎么做。 设 f(i,j)f(i, j)f(i,j) 表示以 iii 为根的子树（必须包含点 iii）异或值为 jjj 的方案数， G(i,j)G(i, j)G(i,j) 以 iii 为根的子树的答案。 考虑更新。对于上一个答案 f′(i,j)f'(i, j)f′(i,j) 当前儿子 vvv 可以更新得到： f(i,j)=∑j=k⊗x
[BZOJ4911][SDOI2017]切树游戏-链分治-快速沃尔什变换
「嫌われ者のフィロソフィ」
12-01 1699
切树游戏Description小Q是一个热爱学习的人，他经常去维基百科学习计算机科学。就在刚才，小Q认真地学习了一系列位运算符，其中按位异或的运算符⊕\oplus对他影响很大。按位异或的运算符是双目运算符。按位异或具有交换律，即i⊕j=j⊕ii \oplus j = j \oplus i。他发现，按位异或可以理解成被运算的数字的二进制位对应位如果相同，则结果的该位置为0，否则为1，例如：1(01)⊕
LOJ2269 [SDOI2017] 切树游戏 【FWT】【动态DP】【树链剖分】【线段树】
weixin_30483495的博客
06-09 100
题目分析： 好题。本来是一道好的非套路题，但是不凑巧的是当年有一位国家集训队员正好介绍了这个算法。 首先考虑静态的情况。这个的DP方程非常容易写出来。 接着可以注意到对于异或结果的计数可以看成一个FWT的过程，进一步地可以注意到FWT在中途没有还原的必要。从FWT的过程中我们可以发现FWT具有可加性和交换律结合律。 这样原问题可以在静态的情况下通过树形DP做到$O(nm)$。 考虑动态...
【BZOJ4911】[SDOI2017]切树游戏（动态dp，FWT）
weixin_30559481的博客
03-21 120
【BZOJ4911】[SDOI2017]切树游戏（动态dp，FWT） 题面 BZOJ 洛谷 LOJ 题解 首先考虑如何暴力\(dp\)，设\(f[i][S]\)表示当前以\(i\)节点为根节点，联通子树权值和为\(S\)的方案数，转移就是\(FWT\)的卷积，最后只需要把所有的\(f[i][k]\)全部加起来就可以得到最终的答案。 于是这样子的复杂度就是\(O(Qnmlogm)\)。但实际上转移的...
洛谷精选：树形数据结构实战题目及模板
本文档是一份针对洛谷在线评测平台上的树形数据结构精选题目的整理，涵盖了线段树、可持久化线段树、树状数组、并查集、平衡树和堆等多种数据结构。这些题目旨在帮助学习者深入理解和掌握这些核心数据结构，并通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值