2018.8.20 练习赛

• T1 图论
• 题面：（待补）
• 搜索模拟，倒推

• #include<stdio.h>
  #define ll long long
  
  //1,2 == 1
  //0,1 == 1
  ll dfs(ll n,ll x,ll y)
  {
      if(n==1) return x==0&&y==1;
      ll k=1<<n-1;
      if(x>=k) return dfs(n-1,x-k,y&k-1);
      if(y>=k) return dfs(n-1,(k<<1)-1-y,x);
      return dfs(n-1,y,k-x-1);
  }
  
  ll n,a,b,c,d;
  int main() {
      scanf("%lld%lld%lld%lld%ld",&n,&a,&b,&c,&d);
      a--,b--,c--,d--;
      for(ll i=a; i<=c; i++,putchar(10))
          for(ll j=b; j<=d; j++)
              printf("%lld",dfs(n,i,j));
  }

   

• T2 数数
• 题面（同 [Jxoi2012]奇怪的道路）
• 记忆化搜索： f[u][l][v][s]   u：起点    l：剩余边数    v：终点    s：[u,u-lim]度的奇偶性   转移见code

• #include<stdio.h>
  #include<string.h>
  #define ll long long
  #define mod 998244353
  
  ll f[35][35][35][1<<9];
  ll n,m,lim;
  
  void inc(ll &a,ll b) {
      a+=b;
      a-=a<mod?0:mod;
  }
  
  ll dfs(ll u,ll l,ll v,ll s) {
      if(l==0) return s==0;
      if(u==1) return 0;
      if(f[u][l][v][s]!=-1) return f[u][l][v][s];
      ll ans=0;
      inc(ans,dfs(u,l-1,v,s^1^(1<<(u-v))));
      if(v>1&&u-v+1<=lim) inc(ans,dfs(u,l,v-1,s));
      else if(!(s&1)) inc(ans,dfs(u-1,l,u-2,s>>1));
      return f[u][l][v][s]=ans;
  }
  
  int main() {
      memset(f,-1,sizeof(f));
      scanf("%lld%lld%lld",&n,&m,&lim);
      printf("%lld",dfs(n,m,n-1,0));
  }

• T3 树上路径
• 题面（待补）
• RMQ区间极值，dfs序将子树问题转换为区间问题，ZKW线段树维护路径信息

• #include<stdio.h>
  #include<algorithm>
  #include<cstring>
  #define ll long long
  #define MAXN 1000005
  using namespace std;
  
  char *p1,*p2,buf[1<<20];
  #define GC (p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?0:*p1++)
  inline int _R(){
      char s=GC;int v=0;
      while(s>57||s<48)s=GC;
      for(;s>47&&s<58;s=GC)v=v*10+s-48;
      return v;
  }
  
  int N,M,Q,w[MAXN];
  int en[MAXN],nex[MAXN],las[MAXN],etot;
  int dep[MAXN],fa[MAXN],In[MAXN],Out[MAXN],vt,E[MAXN],pos[MAXN];
  int Log[MAXN],RMQ[20][MAXN];
  ll C[MAXN];
  
  struct node{
      bool can;
      int u,v,lca;
  }T[MAXN<<2];int m;
  
  ll getsum(int x){
      int i;ll ret=0;
      for(i=x;i;i^=(i&-i))ret+=C[i];
      return ret;
  }
  
  void modify(int x,ll d){
      for(int i=x;i<=N;i+=(i&-i))C[i]+=d;
  }
  
  void link(int x,int y){
      en[++etot]=y;nex[etot]=las[x];las[x]=etot;
      en[++etot]=x;nex[etot]=las[y];las[y]=etot;
  }
  
  void dfs(int x,int pre){
      int i,y;
      dep[x]=dep[pre]+1;
      In[x]=++vt;
      fa[x]=pre;
      E[++E[0]]=x;pos[x]=E[0];
      for(i=las[x];i;i=nex[i]){
          y=en[i];if(y==pre)continue;
          dfs(y,x);
          E[++E[0]]=x;
      }
      Out[x]=vt;
  }
  
  int Min(int a,int b){
      return dep[a]<dep[b]?a:b;
  }
  
  int LCA(int x,int y){
      if(pos[x]>pos[y])swap(x,y);
      int d=pos[y]-pos[x]+1;
      return Min(RMQ[Log[d]][pos[x]],RMQ[Log[d]][pos[y]-(1<<Log[d])+1]);
  }
  
  int dis(int x,int y){return dep[x]+dep[y]-(dep[LCA(x,y)]<<1);}
  
  bool cmp(int a,int b){return dep[a]<dep[b];}
  
  node update(node a,node b){
      node ret;
      int tmp[4],x,y;
      if(!a.can||!b.can){ret.can=false;return ret;}
      if(dep[a.lca]<dep[b.lca])swap(a,b);
  
      if(dis(b.u,a.lca)+dis(b.v,a.lca)!=dis(b.u,b.v)){ret.can=false;return ret;}
      ret.can=true;
  
      tmp[0]=LCA(a.u,b.u);
      tmp[1]=LCA(a.v,b.u);
      tmp[2]=LCA(a.u,b.v);
      tmp[3]=LCA(a.v,b.v);
      sort(tmp,tmp+4,cmp);
      ret.u=tmp[3];ret.v=tmp[2];ret.lca=LCA(ret.u,ret.v);
  
      return ret;
  }
  
  node query(int l,int r){
      bool flag=false;node ret;
      for(l+=m-1,r+=m+1;l^r^1;l>>=1,r>>=1){
          if(~l&1)ret=flag?update(ret,T[l^1]):(flag=true,T[l^1]);
          if(r&1)ret=flag?update(ret,T[r^1]):(flag=true,T[r^1]);
      }
      return ret;
  }
  
  void init(){
      int i,j,n;
      dfs(1,0);
      for(i=2;i<=2*N;i++)Log[i]=Log[i>>1]+1;
      n=E[0];
      for(i=1;i<=n;i++)RMQ[0][i]=E[i];
      for(j=1;j<20;j++)
      for(i=1;i+(1<<j-1)<=n;i++)RMQ[j][i]=Min(RMQ[j-1][i],RMQ[j-1][i+(1<<j-1)]);
  }
  
  int main(){
      int i,op,x,y,v,l,r;
  
      N=_R();
      for(i=1;i<N;i++){
          x=_R();y=_R();
          link(x,y);
      }
  
      init();
  
      for(i=1;i<=N;i++)w[i]=_R(),modify(In[i],w[i]),modify(Out[i]+1,-w[i]);
      M=_R();
      m=1;while(m<=M)m<<=1;
      for(i=m;i<=(m<<1);i++)T[i].can=false;
      for(i=1;i<=M;i++){
          x=_R();y=_R();
          T[m+i]=(node){true,x,y,LCA(x,y)};
      }
      for(i=m-1;i;i--)T[i]=update(T[i<<1],T[i<<1|1]);
  
      Q=_R();
      while(Q--){
          op=_R();
          if(op==1){
              x=_R(),v=_R();
              int d=v-w[x];
              modify(In[x],d);
              modify(Out[x]+1,-d);
              w[x]=v;
          }
          else {
              l=_R(),r=_R();
              node ret=query(l,r);
              if(!ret.can)puts("0");
              else printf("%lld
  ",getsum(In[ret.u])+getsum(In[ret.v])-(getsum(In[fa[ret.lca]])<<1)-w[ret.lca]);
          }
      }
  }