csp-s模拟测试52-53

留坑....

改完题再说吧。

留坑....

最近考得什么鬼？？
模拟53
T1 u（差分）

---

一道差分题？？？？
然而考场没有想到如何维护斜率上的差分，事后经miemeng和cyf的生(xuan)动(xue)讲解大概是懂了
联想如何维护一个矩形的差分？？
假设我们区间修改为L1,R1,L2,R2,
我们在L2+1,R2+1处+1，在L1,R1处+1，在L2+1，R1处-1，在L1,R2+1处-1，然后画图发现从左向右递推时
我们维护的二维前缀和中有+1的部分恰好是区间修改的部分
同理，我们现在维护出一个三角形
首先考虑斜率，假设L1,R1左上角，len为直角边长度，在L1,R1加一，在L1+len,R1+len处-1我们按斜率递推一下就得到斜线上的贡献，然后在考虑直线上的贡献，我们在维护列上的前缀和，然后再按行递推一下就可以画出三角形

#include<bits/stdc++.h>
#define MAXN 2101
#define int long long
using namespace std;
int hang[MAXN][MAXN];int lie[MAXN][MAXN];int sum[MAXN][MAXN];
int n,q;
int read(){
    int x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return x;
}
int ans=0;
signed main(){
    n=read();q=read();
    for(int i=1;i<=q;++i){
        int l=read();int r=read();int len=read();int s=read();
        lie[l][r-1]-=s;
        lie[l+len][r-1]+=s;
        sum[l][r]+=s;
        sum[l+len][r+len]-=s;
    }
    for(int i=1;i<=2*n;++i){
        for(int j=1;j<=2*n;++j){
            sum[i][j]=sum[i][j]+sum[i-1][j-1];
        }
    }
    for(int j=1;j<=2*n;++j){
        for(int i=1;i<=2*n;++i){
            lie[i][j]=lie[i][j]+lie[i-1][j];
        }
    }
    for(int j=2*n;j>=1;--j){
       for(int i=1;i<=n*2;++i){
           hang[i][j]=sum[i][j]+lie[i][j];
           hang[i][j]+=hang[i][j+1];
       }
    }
    for(int i=1;i<=n;++i){
        for(int j=1;j<=n;++j)
        ans^=hang[i][j];
    }
    printf("%lld
",ans);
}

 
T2 v（哈希表，记忆化搜索）

---

第一学了哈系表，因为当前决策不明，而且n的范围很小，所以就记忆化搜索了？？？？

#include<bits/stdc++.h>
#define MAXN 31000001
#define int long long
using namespace std;
int read(){
    int x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return x;
}       
int k;int n;
const int mod=30000001;       
struct map_hash{
       struct node{int to,n;double val;int len;}e[31000001];
       int tot=0; 
       int head[MAXN];int len=0;
       double &operator[](int state){
              int st=state*len%mod+1;
              for(int i=head[st];i;i=e[i].n){
                  if(e[i].to==state&&e[i].len==len)
                  return e[i].val;
              }
              e[++tot].to=state;
              e[tot].val=-1.0; 
              e[tot].len=len;             
              e[tot].n=head[st];
              head[st]=tot;
              return e[tot].val;
       }
}f;
int base[MAXN];
int getnum(int state,int k){
    if(k==0)return (state>>1);
    int kx=(state>>(k+1));
    return (kx<<(k))|(state&base[k-1]);
}
double DFS(int state,int len){
     if(len==n-k)return 0;
     f.len=len;
     if(f[state]!=-1.0)return f[state];
     double sum=0;
     for(int i=1;i<=len/2;++i){
         int ok1=(state>>(i-1))&1;
         int find1=getnum(state,i-1);
         int ok2=(state>>(len-i))&1;
         int find2=getnum(state,len-i);
         sum+=2*max(DFS(find1,len-1)+ok1,DFS(find2,len-1)+ok2); 
     }
     if(len&1){
         int kx=len/2+1;
         int ok1=(state>>(kx-1))&1;
         int find1=getnum(state,kx-1);
         sum+=DFS(find1,len-1)+ok1;
     }
     sum=sum/len;
     f.len=len;
     return f[state]=sum;
}
int st=0;
signed main(){
      n=read();k=read();
      base[0]=1;
      for(int i=1;i<=n;++i)base[i]=base[i-1]|(1<<i);
      for(int i=1;i<=n;++i){
          char x=getchar();
          if(x=='W')st|=1<<(i-1);
      }
      double ans=DFS(st,n);
      printf("%.7lf
",ans);
}

T3 w（神仙DP）

---

第一次作二元组DP很神仙。

性质：1.遇到需要反的边一定要反，遇到不能反的边一定不能反

2.任何操作数其实等于树中翻过的奇数点数/2

所以DP[1/0].fir表示是当前节点是/否向上反边时的计数点个数，sec表示最小路径长度

所以转移时w1,w0分别表示子树贡献，定义同上

转载校外大佬博客（实际是因为自己懒得写了QAQ）

#include<bits/stdc++.h>
using namespace std;
#define min(a,b) (a)<(b)?(a):(b)
#define inf 0x7ffffff
#define MAXN 1000000
#define int long long
int read(){
    int x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return x;
}
struct node{
    int fir;int sec;
    friend node operator +(node a,node b){
        return (node){a.fir+b.fir,a.sec+b.sec};
    }
};
inline node minn(node a,node b){
    if(a.fir==b.fir)return a.sec<b.sec?a:b;
    return a.fir<b.fir?a:b;
}
struct no{
     int n,to,w;
}e[MAXN];
int n;
int head[MAXN],tot;
void add(int u,int v,int w){
     e[++tot].n=head[u];e[tot].to=v;e[tot].w=w;head[u]=tot;
}
node dp[MAXN][2];int fa[MAXN];
void DP(int x,int faa){
     node w0=(node){0,0},w1=(node){inf,inf};
     node t0=(node){0,0},t1=(node){inf,inf};
     for(int i=head[x];i;i=e[i].n){
         int to=e[i].to;
         if(to==faa)continue;
         DP(to,x);
         t0=w0,t1=w1;
         w0=minn(t0+dp[to][0],t1+dp[to][1]);
         w1=minn(t0+dp[to][1],t1+dp[to][0]);
     }
     dp[x][0]=minn((node){w0.fir,w0.sec},(node){w1.fir+1,w1.sec});
     dp[x][1]=minn((node){w0.fir+1,w0.sec+1},(node){w1.fir,w1.sec+1});
     if(fa[x]==0){
         dp[x][1]=(node){inf,inf};
     }
     else if(fa[x]==1){
         dp[x][0]=(node){inf,inf};
     }     
}    
void DFS(int x,int faa){
     for(int i=head[x];i;i=e[i].n){
         int to=e[i].to;
         if(to==faa)continue;
         int w=e[i].w;
         fa[to]=w;
         DFS(to,x);
     }
}
signed main(){
       n=read();
       for(int i=1;i<=n-1;++i){
           int u,v,a,b;
           u=read();v=read();a=read();b=read();
           if(b!=2){add(u,v,a^b);add(v,u,a^b);}
           else add(u,v,b),add(v,u,b);
       }       
       DFS(1,0);
       DP(1,0);
       printf("%lld %lld
",dp[1][0].fir/2,dp[1][0].sec);
}

---

模拟52

T1平均数（归并排序+二分）

---

 发现自己一个小时没有思路，放弃........

一直以为是神仙数据结构.....

其实只要二分平均值后将所有值减去该值，查找和<0的区间个数，

怎么求，归并排序就好了.....

#include<bits/stdc++.h>
#define MAXN 101000
#define int long long
#define inf 0.00001
using namespace std;
double sum[MAXN],kx[MAXN];double zzn[MAXN];double maxn;
int read(){
    int x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return x;
}
int anss=0;int n;int a[MAXN];int k;
void guibing(int l,int r){
     if(l==r){kx[l]=sum[l];return ;}
     int mid=(l+r)>>1;
     guibing(l,mid);guibing(mid+1,r);
     int le=l;int re=mid+1;int mm=0;
     while(le<=mid&&re<=r){
           if(kx[re]<kx[le]){zzn[++mm]=kx[le];le++;}
           else{ 
               zzn[++mm]=kx[re];
               anss+=(le-l);
               re++;
           }
     }
     while(le<=mid){
           zzn[++mm]=kx[le];le++;
     }
     while(re<=r){
           zzn[++mm]=kx[re];anss+=(le-l);
           re++;
     }
     for(int i=l;i<=r;++i){
         kx[i]=zzn[i-l+1];
     }
}
int work(double len){
    anss=0;
    for(int i=1;i<=n;++i){
        sum[i]=sum[i-1]+((double)a[i]-len);
        if(sum[i]<0)anss++;
        kx[i]=0.0;
    }
    guibing(1,n);
    return anss;
}
void second_divied(){
     double l=0;double r=maxn;
     while(l+inf<r){
           double mid=(l+r)/2.000;
           if(work(mid)<k)l=mid;
           else r=mid;
     }
     if(work(l)==k)printf("%.4lf
",l);
     else printf("%.4lf
",r);
}
signed main(){
     n=read();k=read();
     for(int i=1;i<=n;++i)a[i]=read(),maxn=max(maxn,(double)a[i]);
     second_divied();   
}

***********************

思路积累：

1.求排名第k小转化为有k个比他小的序列

2.平均数可以二分后，让所有数减去该值。

T2涂色游戏（组合数学）

---

 考场死刚.....

最后式子推的基本对了，但是还是有点问题，快速幂打错怒丢30！！！

首先要处理好j,k两列颜色种类有x个颜色交集时的方案数

还要与处理出在n行放k种颜色的方案数

然后转移时发现对于该列有j种颜色，我们先乘f[n][j]/C(p,j)表明我们并不知道所放颜色的具体颜色，只知道一个排列顺序，

对于每一个上一列的状态我们可以转移到该列，

然后乘上相应组合数求出上一列颜色固定时下一列的颜色种类的方案，再乘上排列方式即可

#include<bits/stdc++.h>
#define int long long
#define MAXN 1100
using namespace std;
int read(){
    int x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return x;
}
int n,m,p,q;
int dp[MAXN][MAXN];
int jie[MAXN],ni[MAXN],ni_c[MAXN];
const int mod=998244353ll;
int C(int x,int y){
    if(y>x)return 0;
    if(y==0)return 1;
    return jie[x]*ni_c[y]%mod*ni_c[x-y]%mod;
}
int poww(int x,int y){
    int ans=1ll;
    while(y){
          if(y&1)ans=(ans*x)%mod;
          x=(x*x)%mod;
          y>>=1;
    }
    return ans%mod;
}
int ans=0;int kx[MAXN][MAXN];
int fir[MAXN][MAXN];int f[2][MAXN];int c[MAXN][MAXN];
void work1(){
     memset(c,0,sizeof(c));
     for(int k=1;k<=min(n,p);++k){
         for(int i=1;i<=min(n,p);++i){
             for(int j=1;j<=min(n,p);++j){
                 c[i][j]=(c[i][j]+fir[i][k]*kx[k][j]%mod)%mod;
             }
         }
     }
     for(int i=1;i<=min(n,p);++i){
        for(int j=1;j<=min(n,p);++j)
           fir[i][j]=c[i][j]%mod;
     }
}
void work2(){
     memset(c,0,sizeof(c));
     for(int k=1;k<=min(n,p);++k){
         for(int i=1;i<=min(n,p);++i){
            for(int j=1;j<=min(n,p);++j){
                c[i][j]=(c[i][j]+kx[i][k]*kx[k][j]%mod)%mod;
            } 
         }
     }
     for(int i=1;i<=min(n,p);++i){
        for(int j=1;j<=min(n,p);++j)
           kx[i][j]=c[i][j];
     }
}
void ju_poww(int y){
     for(int i=1;i<=min(n,p);++i)fir[i][i]=1;
     while(y){
           if(y&1){work1();}
           work2();
           y>>=1;
     }
}
signed main(){
      n=read();m=read();p=read();q=read();
      dp[0][0]=1;
      for(int i=1;i<=n;++i){
          for(int j=1;j<=min(p,i);++j){
              dp[i][j]=(dp[i-1][j-1]*(p-(j-1)+mod)%mod+dp[i-1][j]*j%mod)%mod;
          }
      }
      jie[0]=jie[1]=1;ni[1]=1;ni_c[0]=ni_c[1]=1;
      for(int i=2;i<=p;++i){
          jie[i]=(jie[i-1]*i)%mod;
          ni[i]=((mod-mod/i)*ni[mod%i])%mod;
          ni_c[i]=(ni[i]*ni_c[i-1])%mod;
      }
      for(int j=1;j<=p;++j){
          f[0][j]=dp[n][j]%mod;                  
      }
      for(int j=1;j<=min(n,p);++j){
          for(int k=1;k<=min(n,p);++k){
              if(j+k<q)continue;
              for(int x=max(j,max(q,k));x<=min(p,j+k);++x){
                  kx[j][k]=(kx[j][k]+C(p-j,x-j)%mod*C(j,k+j-x)%mod)%mod;              
              }
              kx[j][k]%=mod;
              kx[j][k]=kx[j][k]*poww(C(p,k)%mod,mod-2)%mod*dp[n][k]%mod;
              kx[j][k]%=mod;
          }
      }
      ju_poww(m-1);
      for(int j=1;j<=p;++j){
          for(int k=1;k<=p;++k){
              f[1][j]=(f[1][j]+f[0][k]*fir[k][j]%mod)%mod;
          }
      }
      int ans=0;
      for(int j=1;j<=p;++j)ans=(ans+f[1][j])%mod;
      printf("%lld
",ans);
}

T3序列（数据结构乱搞）

---

 好像是这套题里最简单的......

直接在树状数组里开vector每次查询时就lowerbound查出贡献

对于查询覆盖了一段区间的查询，我们在L,R+1处用两个树状数组标记后缀

然后对于询问覆盖x位置的值就用L的（1-x）的L贡献-（1-x）的R的贡献

#include<bits/stdc++.h>
#define MAXN 410000
#define int long long
using namespace std;
vector<int>v[MAXN];vector<int>v1[MAXN];
int lowbit(int x){return x&(-x);}
int m,q,n,a[MAXN];
void add(int x,int k){
     for(int i=x;i>=1;i-=lowbit(i)){
         v[i].push_back(k);//printf("ps=%lld i=%lld
",i,k);
     }
}
void add1(int x,int k){
     for(int i=x;i>=1;i-=lowbit(i)){
         v1[i].push_back(k);//printf("ps=%lld i=%lld
",i,k);
     }
}
int anss[MAXN];
void pt(int x){
     for(int i=0;i<v[x].size();++i){
         printf("%lld ",v[x][i]);
     }cout<<endl;
}
int query(int x,int k){
     int ans=0;
     for(int i=x;i<=n+1;i+=lowbit(i)){
         int kx=upper_bound(v[i].begin(),v[i].end(),k)-v[i].begin()-1;
         ans+=kx;
     }
     return ans;
}
int query1(int x,int k){
     int ans=0;
     for(int i=x;i<=n+1;i+=lowbit(i)){
         int kx=upper_bound(v1[i].begin(),v1[i].end(),k)-v1[i].begin()-1;
         ans+=kx;
     }
     return ans;
}
int read(){
    int x=0;char c=getchar();
    while(c<'0'||c>'9')c=getchar();
    while(c>='0'&&c<='9'){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
    return x;
}
int sum=0;
signed main(){
    n=read();m=read();q=read();
    for(int i=1;i<=n+1;++i){v[i].push_back(0);v[i].push_back(0x7fffffffffff);v1[i].push_back(0);v1[i].push_back(0x7fffffffffff);}
    for(int i=1;i<=n;++i){
        a[i]=read();
    }     
    for(int i=1;i<=m;++i){
        int l=read();int r=read();int xx=read();
        add(l,xx);
        add1(r+1,xx);
    }
    for(int i=1;i<=n+1;++i)sort(v[i].begin(),v[i].end()),sort(v1[i].begin(),v1[i].end());
    for(int i=1;i<=n;++i){
        anss[i]=(query(1,a[i])-query(i+1,a[i]));
        anss[i]-=(query1(1,a[i])-query1(i+1,a[i]));
        sum+=anss[i];
    }
    printf("%lld
",sum);
    for(int i=1;i<=q;++i){
        int u=read();int v=read();
        u^=sum;v^=sum;
        sum-=anss[u];
        anss[u]=query(1,v)-query(u+1,v);
        anss[u]-=(query1(1,v)-query1(u+1,v));        
        sum+=anss[u];
        a[u]=v;
        printf("%lld
",sum);
    }
}
/*
4 2 2 
1 4 2 3 
2 4 3 
1 3 2
6 6
2 7
*/