11.24 模拟赛

T1 bzoj 4730 Alice和Bob又在玩游戏

题目大意：

Alice和Bob在玩游戏 n个节点，m条边(0<=m<=n-1)，构成若干棵有根树，每棵树的根节点是该连通块内编号最小的点

Alice和Bob轮流操作，每回合选择一个没有被删除的节点x，将x及其所有祖先全部删除，不能操作的人输

思路：

根据博弈论的一些定理可以得到一个优秀的$n^2$做法

由$SG$定理得 每个点的$SG$函数值为$mex${子树内一个点的SG xor 该根节点其余儿子的SG}

因此对于每个点我们可以开一个trie树表示这个点的SG集合

合并的时候每个子树的$trie$树$xor$其余子树的$xor$和 然后像线段树合并一样合并$trie$树即可

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<map>
#define rep(i,s,t) for(register int i=(s);i<=(t);++i)
#define dwn(i,s,t) for(register int i=(s);i>=(t);--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define inf 2139062143
#define MAXN 200100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,fst[MAXN],to[MAXN<<1],nxt[MAXN<<1],cnt,vis[MAXN],sg[MAXN];
int ls[MAXN*20],rs[MAXN*20],tag[MAXN*20],tot,ans,sz[MAXN*20],rt[MAXN*20];
const int maxDep=16;
void add(int u,int v) {nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v;}
void pshd(int k,int Dep)
{
    if((tag[k]>>Dep)&1) swap(ls[k],rs[k]);
    tag[k]&=((1<<Dep)-1);
    tag[ls[k]]^=tag[k],tag[rs[k]]^=tag[k],tag[k]=0;
}
int merge(int x,int y,int Dep)
{
    if(!(x*y)) return x|y;
    pshd(x,Dep);pshd(y,Dep);
    ls[x]=merge(ls[x],ls[y],Dep-1),rs[x]=merge(rs[x],rs[y],Dep-1);
    return x;
}
void ins(int &x,int val,int Dep)
{
    if(!x) x=++tot,sz[x]=1,ls[x]=rs[x]=tag[x]=0;if(!(~Dep)) return ;
    pshd(x,Dep);ins((val&(1<<Dep))?rs[x]:ls[x],val,Dep-1);
    sz[x]=sz[ls[x]]+sz[rs[x]];
}
int mex(int x,int res=0)
{
    dwn(i,maxDep,0)
    {
        if(sz[ls[x]]<(1<<i)) x=ls[x];
        else res|=(1<<i),x=rs[x];
    }
    return res;
}
void dfs(int x,int fa)
{
    int sum=0;vis[x]=1;
    ren if(to[i]!=fa) {dfs(to[i],x);sum^=sg[to[i]];}
    ren if(to[i]!=fa) {tag[rt[to[i]]]^=(sum^sg[to[i]]);rt[x]=merge(rt[x],rt[to[i]],maxDep);}
    ins(rt[x],sum,maxDep);sg[x]=mex(rt[x]);
}
int main()
{
    int T=read();
    while(T--)
    {
        n=read(),m=read(),tot=cnt=ans=0;int a,b;
        while(m--) {a=read(),b=read();add(a,b);add(b,a);}
        rep(i,1,n) if(!vis[i]) {dfs(i,0);ans^=sg[i];}
        puts(ans?"Alice":"Bob");
        rep(i,1,n) fst[i]=vis[i]=sg[i]=rt[i]=0;
    }
}

T2 bzoj 4731 魔法小程序

题目大意：

有这样一段魔法的程序：（其中所有的数组下标从0 开始，所有的除法的结果为整数，且向0取整）

现在给出数组$c$ 求数组$b$

思路：

相当于对每个数拆成一个K维空间的点 每一维长度不一样 数组$a$代表每一维的长度

$c_i$为这个K维空间内第i个点所对应多维立方体内的点权和（相当于前缀和

因为一共只有m个点 所以有意义且长度大于1的点不超过$log space m$个

因此我们可以暴力把这些维数还原回去

对于每一维 我们从m-1枚举到0 可以减去次一维的立方体的影响

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<map>
#define rep(i,s,t) for(register int i=(s);i<=(t);++i)
#define dwn(i,s,t) for(register int i=(s);i>=(t);--i)
#define ren for(int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define inf 2139062143
#define MAXN 1001000
using namespace std;
inline ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
ll n,m,a[MAXN],c[MAXN],mul[MAXN];
int main()
{
    n=read();printf("%d
",n);rep(i,0,n-1) {a[i]=read();printf("%lld ",a[i]);if(a[i]==1) n--,i--;}
    m=read();rep(i,0,m-1) c[i]=read();mul[0]=1,a[n++]=inf;int x,y;
    rep(i,1,n-1) {mul[i]=mul[i-1]*a[i-1];if(mul[i]>m) {n=i;break;}}
    rep(i,0,n-1)
    {
        x=m%mul[i],y=(m/mul[i])%a[i];
        dwn(j,m-1,0) {if(x) x--;else x=mul[i]-1,y=y?y-1:a[i]-1;if(y) c[j]-=c[j-mul[i]];}
    }
    printf("
%d
",m);
    rep(i,0,m-1) printf("%lld ",c[i]);
}

bzoj 4732 数据交互

这道ddp并不可做（因为甚至没学ddp 有机会再回来

发现了这题的树剖做法非常强

题目大意：

每次可以对一个链安排或删除一个权值使这个链上的点都具有这个权值

每次求一个权值和最大的链（同时被安排的权值只能算一次）

思路：

由于每一次修改的在统计时只算一次 我们可以考虑维护两个数组表示是否以这个点的lca的路径上该点的权值

设$a_i$表示以$i$点为lca的路径的权值和 $b_i$表示经过$i$点且lca不为$i$的路径的权值和

对于每条路径答案即为$b_{lca} + sum_{x in path} a_x $

同时 一条路径也一定可以分为重链$(u,v)，(dep_u le dep_v)$ ; （$v - $ 轻儿子）;轻儿子再引出的重链

因此对于全局权值和最大的链 用线段树来维护每条重链的答案 相当于维护最大连续和

对于每一个点开一个可删堆来维护它最大的轻儿子子链

每次修改的时候 对于这条链 改动b数组 区间修改沿途的重链的答案（只修改最大后缀因为沿途的答案为后缀

当达到lca时 继续向上走 单点修改每个点的答案（修改每个新进入重链的点的最大前后缀为经过轻儿子的堆顶，最大值为经过轻儿子的两个堆顶和）

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
#include<queue>
#include<map>
#define rep(i,s,t) for(register int i=(s),i__end=(t);i<=i__end;++i)
#define dwn(i,s,t) for(register int i=(s),i__end=(t);i>=i__end;--i)
#define ren for(register int i=fst[x];i;i=nxt[i])
#define Fill(x,t) memset(x,t,sizeof(x))
#define ll long long
#define inf 2139062143
#define MAXN 100100
using namespace std;
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)) {if(ch=='-') f=-1;ch=getchar();}
    while(isdigit(ch)) {x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int n,m,fst[MAXN],nxt[MAXN<<1],to[MAXN<<1],cnt,tot;
int fa[MAXN],dep[MAXN],bl[MAXN],hvs[MAXN],sz[MAXN],dfn[MAXN],lfs[MAXN];
int qu[MAXN],qv[MAXN],qw[MAXN];
struct node{ll sum,mx,lm,rm,tag;}tr[MAXN<<2];
struct Heap
{
    priority_queue<ll> A,B;
    void push(ll x) {A.push(x);}
    ll top() {while(!B.empty()&&A.top()==B.top()) A.pop(),B.pop();return A.top();}
    void pop(ll x) {B.push(x);}
}q[MAXN],ans;
void add(int u,int v) {nxt[++cnt]=fst[u],fst[u]=cnt,to[cnt]=v;}
void dfs(int x,int pa)
{
    fa[x]=pa,dep[x]=dep[pa]+1,sz[x]=1;
    ren if(to[i]!=pa) {dfs(to[i],x);sz[x]+=sz[to[i]];if(sz[to[i]]>sz[hvs[x]]) hvs[x]=to[i];}
}
void Dfs(int x,int anc)
{
    bl[x]=anc,dfn[x]=++tot,lfs[x]=x;if(!hvs[x]) return ;Dfs(hvs[x],anc);
    lfs[x]=lfs[hvs[x]];ren if(to[i]!=fa[x]&&to[i]!=hvs[x]) Dfs(to[i],to[i]);
}
void pshd(int k,node &a,node &b,ll x=0) {x=tr[k].tag,a.tag+=x,b.tag+=x,a.rm+=x,b.rm+=x,a.mx+=x,b.mx+=x,tr[k].tag=0;}
node upd(node a,node b,int x) {return (node){a.sum+b.sum,max(max(a.mx,b.mx),a.rm+b.lm),max(a.lm,a.sum+b.lm),max(b.rm,b.sum+a.rm),x};}
void Mdf(int k,int l,int r,int x,ll a,ll b,ll c)
{
    if(l==r) {tr[k].lm+=a+c,tr[k].rm+=a+c,tr[k].mx+=b+c,tr[k].sum+=c;return ;}
    int mid=(l+r)>>1;if(tr[k].tag) pshd(k,tr[k<<1],tr[k<<1|1]);
    if(x<=mid) Mdf(k<<1,l,mid,x,a,b,c);else Mdf(k<<1|1,mid+1,r,x,a,b,c);
    tr[k]=upd(tr[k<<1],tr[k<<1|1],0LL);
}
void mdf(int k,int l,int r,int a,int b,ll w)
{
    if(l==a&&r==b) {tr[k].mx+=w,tr[k].rm+=w,tr[k].tag+=w;return ;}
    int mid=(l+r)>>1;if(tr[k].tag) pshd(k,tr[k<<1],tr[k<<1|1]);
    if(b<=mid) mdf(k<<1,l,mid,a,b,w);
    else if(a>mid) mdf(k<<1|1,mid+1,r,a,b,w);
    else {mdf(k<<1,l,mid,a,mid,w);mdf(k<<1|1,mid+1,r,mid+1,b,w);}
    tr[k]=upd(tr[k<<1],tr[k<<1|1],0LL);
}
node query(int k,int l,int r,int a,int b)
{
    if(l>r) return (node){0,0,0,0,0};if(l==a&&r==b) return tr[k];
    int mid=(l+r)>>1;if(tr[k].tag) pshd(k,tr[k<<1],tr[k<<1|1]);
    if(b<=mid) return query(k<<1,l,mid,a,b);
    else if(a>mid) return query(k<<1|1,mid+1,r,a,b);
    else return upd(query(k<<1,l,mid,a,mid),query(k<<1|1,mid+1,r,mid+1,b),0LL);
}
ll calc(int x) {ll res=0,tmp;res=tmp=q[x].top();q[x].pop(tmp);res+=q[x].top();q[x].push(tmp);return res;}
void work(int x,int y,int w)
{
    while(bl[x]!=bl[y])
    {
        if(dep[bl[x]]<dep[bl[y]]) swap(x,y);
        ans.pop(query(1,1,n,dfn[bl[x]],dfn[lfs[x]]).mx);mdf(1,1,n,dfn[bl[x]],dfn[x],w);
        ans.push(query(1,1,n,dfn[bl[x]],dfn[lfs[x]]).mx);x=fa[bl[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);node p;ll a=0LL,b=0LL;
    if(x!=y)
    {
        ans.pop(query(1,1,n,dfn[bl[x]],dfn[lfs[x]]).mx);mdf(1,1,n,dfn[x]+1,dfn[y],w);
        ans.push(query(1,1,n,dfn[bl[x]],dfn[lfs[x]]).mx);
    }
    while(x)
    {
        p=query(1,1,n,dfn[bl[x]],dfn[lfs[x]]);Mdf(1,1,n,dfn[x],b,a,w);
        a=-calc(fa[bl[x]]),b=-q[fa[bl[x]]].top(),w=0LL;
        ans.pop(p.mx);q[fa[bl[x]]].pop(p.lm);
        p=query(1,1,n,dfn[bl[x]],dfn[lfs[x]]);ans.push(p.mx);q[fa[bl[x]]].push(p.lm);
        a+=calc(fa[bl[x]]),b+=q[fa[bl[x]]].top(),x=fa[bl[x]];
    }
}
int main()
{
    n=read(),m=read();int a,b,c;char ch[3];rep(i,0,n<<1|1) q[i>>1].push(0LL);ans.push(0LL);ans.push(0LL);
    rep(i,2,n) {a=read(),b=read();add(a,b);add(b,a);}dfs(1,0);Dfs(1,1);
    rep(i,1,m)
    {
        scanf("%s",ch);
        if(ch[0]=='+') {qu[i]=read(),qv[i]=read(),qw[i]=read();work(qu[i],qv[i],qw[i]);}
        else {a=read();work(qu[a],qv[a],-qw[a]);}
        printf("%lld
",ans.top());
    }
}