CSP-S 模拟53 题解

题解：

T1 u：

一看到修改这么多，但询问其实只有一个不难想到差分，但是他这个形状可以说很不规则，于是我们想到分别维护竖着的和斜着的差分，然后最后合并即可。

考场上瞎调了一波系数莫名AC，其实是维护差分的差分。

考试时发现对拍暴力输不出来东西时，慌的不行，对拍的数据范围一定要搞对。

 //weihu xiezhede chafen?
 //对于每个满足 x ∈ [r, r +l), y ∈ [c, x−r +c]
 //的元素 (x, y),将权值增加 s。
 #include<bits/stdc++.h>
 using namespace std;
 #define int long long
 #define sc(x) printf("%lld\n",x)
 const int N=1e3+;
 int cf[N][N],cf1[N][N],n,q,a[N][N];
 signed main(){
     //freopen("data.in","r",stdin);
     //freopen("my.out","w",stdout);
     scanf("%lld%lld",&n,&q);
     if(!q){puts("");return ;}
     for(int i=;i<=q;++i){
         int r,c,l,s;
         scanf("%lld%lld%lld%lld",&r,&c,&l,&s);
         cf[r][c]+=s;
         cf1[r][c+]+=s;
         if(r+l<=n) cf[r+l][c]-=s;
         if(r+l<=n&&c+l+<=n) cf1[r+l][c+l+]-=s;
     }
     for(int i=;i<=n;++i) for(int j=;j<=n;++j) cf[i][j]+=cf[i-][j];
     for(int i=;i<=n;++i) for(int j=;j<=n;++j) cf1[i][j]+=cf1[i-][j-];
     int ans=;
     for(int i=;i<=n;++i){
         for(int j=;j<=n;++j){
             cf[i][j]-=cf1[i][j];
         }
     }
 //    ans=cf[1][1];
     for(int i=;i<=n;++i){
         for(int j=;j<=n;++j){
             cf[i][j]+=cf[i][j-];
             //cout<<cf[i][j]<<" ";
             ans^=cf[i][j];
         }
         //cout<<endl;
     }
     sc(ans);
 }

u

T2 v：

考场上想状压，但是发现数据范围稍大，可能过不了，然后也没什么思路。

正解 记忆化搜索+hash_map，其实是和裸状压一样的，但是加了记忆化加速，比较难搞的一点就是如何把删了一个球后的状态用二进制表示出来，有点绕。

还有就是，hash_map不能仅仅记录状态，还要记录当前所剩的球数，因为000110和000110对于状态来说是一样的，但是前面的黑球数是不一定的，这样保证状态唯一。所以hash_map有点难搞，%%%DeepinC重载中括号取地址hash_map，因为自己是实在是不会hash_map，所以就没脸得照着DeepinC神的hash_map打了。

 #include<bits/stdc++.h>
 using namespace std;
 const int N=;
 #define signed long long
 const int M=3e7+;
 char s[N];
 int n,k,a[N];
 struct hash_map{//hash_map shizhaozhe DeepinC dedade zhendebuhui hash_map
     int first[],nex[M],to[M],tot;short l[M],len;
     double val[M];
     double &operator[] (const register int st){
         signed f=st*1ll*len%;
         for(register int i=first[f];i;i=nex[i]) if(to[i]==st&&l[i]==len) return val[i];
         to[++tot]=st,nex[tot]=first[f],first[f]=tot,l[tot]=len; val[tot]=-;return val[tot];
     }
 }mp;
 inline double max(const register double  a,const register double b){
     return a>b?a:b;
 }

 double dfs(const register int l,const register int st){//cout<<l<<" "<<st<<endl;
     if(l==n-k) return 0.0;
     mp.len=l;//meicichongxinfuzhi,yinwei zhuangtaihechangdushiduiyingde
     if(mp[st]>-0.1) return mp[st];
     mp[st]=;
     short sta[N],jk=l+,kh=(l>>)+;
     for(register int i=;i^jk;++i) sta[i]=(st>>i-)&;
 //    reverse(sta+1,sta+l+1);
 //    for(int i=1;i<=l;++i) cout<<sta[i]<<" ";cout<<endl;

     for(register int  i=;i^kh;++i){
         short h=l-i+;
         int state1=st>>l-i+<<l-i|st&(<<l-i)-,state2=st>>l-h+<<l-h|st&(<<l-h)-;
 //        cout<<st<<" "<<l<<" "<<i<<endl;
 //        cout<<state1<<" "<<state2<<endl;
         double ans1=dfs(l-,state1)+sta[h],ans2=dfs(l-,state2)+sta[i];
         mp.len=l;mp[st]+=(2.0*max(ans1,ans2))/(1.0*l);
     }
     if(l&){
         int i=kh;
         int state=st>>l-i+<<l-i|st&(<<l-i)-;
         double ans=dfs(l-,state)+sta[i];
         mp.len=l;mp[st]+=ans/(1.0*l);
     }
     return mp[st];
 }

 int main(){
     scanf("%d%d",&n,&k);
     scanf("%s",s+);
     int st=;
     for(register signed i=;i<=n;++i) a[i]=(s[i]=='W');
     for(register signed i=;i<=n;++i) st=st<<|a[i];
     printf("%.7lf",dfs(n,st));
 }

v

T3:

考场上以为是个贪心，就和虎那题差不多，实际上是个思路非常好的dp

首先贪心地考虑，每个边顶多被覆盖一次，因为被覆盖两次以上完全可以从这条便断开，那么会使答案更优。

我们设$dp[i][0/1]$表示以点i为根的子树否/是向上伸，因为他的两个答案是同时更新的，所以。

然后考虑对于i的儿子y，我们设两个二元组w1,w2，w1表示向上伸，w2表示不向上伸。

那么我们考虑转移$w1=min(w1+dp[y][0],w2+dp[y][1])$,$w2=min(w1+dp[y][1],w2+dp[y][0])$

那么我们在来考虑怎么用w1,w2进行转移。

如果他这条边不翻转，那么能不反转就不反转，所以$dp[x][1]=(INF,INF)$,$dp[x][0]=min(w2,(w1.first+1,w1.second))$

如果必须反转的话，那么同理$dp[x][0]=(INF,INF)$,$dp[x][1]=min((w1.first,w1.second+1),(w2.first+1,w2.second+1))$

最后答案就是$dp[1][0].first/2$和$dp[1][0].second$

 #include<bits/stdc++.h>
 using namespace std;
 const int N=3e5+,INF=1e9+;
 int first[N],nex[N<<],to[N<<],edge[N<<],tot;
 void add(int a,int b,int c){
     to[++tot]=b,nex[tot]=first[a],first[a]=tot,edge[tot]=c;
 }
 pair<int ,int> min(pair<int ,int> a,pair<int ,int > b){
     return a<b?a:b;
 }
 pair<int ,int> add(pair<int,int> a,pair<int ,int> b){
     return make_pair(a.first+b.first,a.second+b.second);
 }
 pair<int ,int> dp[N][];//0 not up 1 up
 void dfs(int x,int fa,int ed){
     pair<int ,int > p,q;
     p=make_pair(INF,INF);//up
     q=make_pair(,);//not up
     pair<int ,int> tmp1,tmp2;//p q;
     for(int i=first[x];i;i=nex[i]){
         int y=to[i];
         if(y==fa) continue;
         dfs(y,x,edge[i]);
         tmp1=min(add(p,dp[y][]),add(q,dp[y][]));
         tmp2=min(add(q,dp[y][]),add(p,dp[y][]));
         p=make_pair(tmp1.first,tmp1.second);
         q=make_pair(tmp2.first,tmp2.second);
     }
     if(ed==||ed==){//bi fan
         dp[x][]=min(make_pair(p.first,p.second+),make_pair(q.first+,q.second+));
     }else dp[x][]=make_pair(INF,INF);
     if(ed==||ed==){//bu fan
         dp[x][]=min(q,make_pair(p.first+,p.second));
     }else dp[x][]=make_pair(INF,INF);
 }

 int main(){
     int n;
     scanf("%d",&n);
     for(int i=;i<n;++i){
         int a,b,c,d;
         scanf("%d%d%d%d",&a,&b,&c,&d);
         int opt;
         if(d==) opt=;
         else if(c^d) opt=;
         else opt=;
         add(a,b,opt);
         add(b,a,opt);
     }
     dfs(,,);
     printf("%d %d",dp[][].first>>,dp[][].second);
 }