牛客CSP-S提高组赛前集训营1

牛客CSP-S提高组赛前集训营1

比赛链接

官方题解

before：T1观察+结论题，T2树形Dp，可以换根或up&down，T3正解妙，转化为图上问题。题目质量不错，但数据太水了~。

A-仓鼠的石子游戏

题目描述

一共n个石子堆，每个石子堆有ai个石子，两人轮流对石子涂色(先手涂红，后手涂蓝)，且需要保证当前回合涂的石子颜色不能和它相邻的两个同色，谁涂不下去谁输。一共T个询问，对于每个询问输出先手必胜还是后手必胜。

\(1<=n<=10^3，1<=ai<=10^9，1<=T<=10^2\)

题解

标签：模拟，猜结论

当n=1时，模拟一下可以发现，除非石子数=1，否则后手必胜。当增加多堆石子时，假设当前局面是P必败，则P肯定要去新的一堆里涂，则对于新的一堆石子P成为了先手，假设新的一堆石子数>1，则P任然必败，反之可以转移，P的另一方成为了下一堆的先手。也就是说只有数量为1的石子堆能够改变胜负状态。

所以，只需统计石子数为1的堆的数量\(cnt1\)，根据\(cnt1\)的奇偶性来判断。若为奇，则先手必胜；反之先手必败。

#include<bits/stdc++.h>
using namespace std;
inline int read(){}
int main(){
     int T=read();
     while(T--){
        int n=read();
        bool o=0;
        for(register int i=1;i<=n;i++){
            int x=read();
            if(x==1)o^=1;  
        }
        if(o==0)puts("hamster");
        else puts("rabbit");
     }
}

---

B- 乃爱与城市拥挤程度

题目描述

见原题面。

题解

标签：树形Dp，换根法，Up and Down

暴力做法是\(O(N^2)\)的，将每个点都提做根跑一遍树形dp。优化很明显是去换根。

由于标程给的换根法写的非常板子(虽然有点长)，所以这里按标程的思路走一遍，整理一下换根法的大致思路。

step1：预处理dfs

随便找一个节点作为根，进行dfs/树形Dp，处理出所有节点此时的答案（只考虑自己子树下的答案）。

step2：换根

平时做题打换根都是直接去统计，加加减减，虽然码量小但不同的题目细节不同，调试起来不太方便。标程中将换根分为两部分。第一部分\(cut\)，先分别消除彼此的影响，逆操作；第二部分\(link\)，对更改后的数组正操作一遍。

在本题中有两个询问。弄两个数组分别针对题目的两个询问，第一个比较好理解，第二个比较抽象，根据代码y一下。

\(dp[x][i]\)：换根前，只考虑x的子树时，与x距离为i的子孙数量。

\(dp2[x][i]\)：换根前，只考虑x的子树时，当影响范围为i时，x影响到的子孙的拥挤程度之乘积。

将节点1作为根，预处理dfs一遍。下面的操作都是将\(sonx\)的贡献加给\(x\)的正操作。

void dp_dfs(int x,int fa){
    dp[x][0]=1;
    for(int i=0;i<=k;++i)dp2[x][i]=1;
    for(int i=0;i<G[x].size();++i){
        if(G[x][i]!=fa){
            dp_dfs(G[x][i],x);
            for(int j=1;j<=k;++j){
                dp[x][j]+=dp[G[x][i]][j-1];
                dp2[x][j]=dp2[x][j]*dp2[G[x][i]][j-1]%mod;
            }
        }
    }
    long long sum=0;
    for(int i=0;i<=k;++i){
        sum+=dp[x][i];
        dp2[x][i]=dp2[x][i]*sum%mod;
    }
}

这一遍dfs后，此时的根节点1已经可以直接统计出答案了，但对于其他非根节点来说，它们只考虑了自己子树内的贡献，还需考虑子树外的贡献。

接下来再dfs一遍，换根。

void change_root(int root1,int root2) {
    //原来的根:root1 现在要换为:root2，且root1之前是root2的父节点
    cut_dp(root1,root2);//逆操作
    link_dp(root2,root1);//正操作，重新统计一遍
}

逆操作、正操作都与之前的预处理dfs类似。

标程的换根法代码

无根树Dp还可以up and down去做。网上关于这一块内容不多，而且很多blog都说和换根法差不多。

比如对于这题的询问一，要求树中离x距离小于等于k的节点数目，可以分解为这样两个问题，①x子树中距离小于等于k的节点数目+②x子树外距离小于等于k的节点数目，对这两个问题分别dfs一遍，问题①用儿子更新自己，问题②用自己更新儿子，最后将两部分的贡献合起来。好像确实和换根差不多，但实现起来感觉up&down的思路更清晰些。

下面是up&down的代码

#include<bits/stdc++.h>
#define Mod 1000000007
#define int long long
using namespace std;
const int N=1e5+10;
vector<int>g[N];
int num[N][11],dp[N][11];
int outnum[N][11],outdp[N][11];
int n,k,ans1[N],ans2[N];
namespace UpandDown{
    int ksm(int x,int d){
        int res=1;
        while(d){
            if(d&1)res=res*x%Mod;
            x=x*x%Mod;d>>=1;
        }
        return res;
    }
    void dfs(int x,int fa){
        for(int i=0;i<g[x].size();i++)if(g[x][i]!=fa)dfs(g[x][i],x);
        num[x][0]=1,dp[x][0]=1;
        for(int i=1;i<=k;++i){
            num[x][i]=1,dp[x][i]=1;
            for(int j=0;j<g[x].size();++j){
                int y=g[x][j];if(y==fa)continue;
                num[x][i]+=num[y][i-1];
                dp[x][i]=dp[x][i]*dp[y][i-1]%Mod;
            }
            dp[x][i]=dp[x][i]*num[x][i]%Mod;        
        }
    }
    void redfs(int x,int fa){
        if(x==1){
            ans1[x]=num[x][k];
            ans2[x]=dp[x][k];
        }
        else{
            ans1[x]=num[x][k]+outnum[x][k];
            ans2[x]=dp[x][k]*ksm(num[x][k],Mod-2)%Mod*(num[x][k]+outnum[x][k])%Mod*outdp[x][k]%Mod;
        }
        for(int i=0;i<g[x].size();i++){
            int y=g[x][i];if(y==fa)continue;
            outnum[y][1]=1,outdp[y][1]=1;
            for(int j=2;j<=k;j++){
                outnum[y][j]=outnum[x][j-1]+num[x][j-1]-num[y][j-2];
                outdp[y][j]=outdp[x][j-1]*dp[x][j-1]%Mod*ksm(dp[y][j-2],Mod-2)%Mod*
                ksm(num[x][j-1],Mod-2)%Mod*(num[x][j-1]-num[y][j-2]+outnum[x][j-1])%Mod;
            }
            redfs(y,x);
        }
    }
    void solve(){
        for(int i=1;i<=k;i++)for(int j=1;j<=k;j++)outdp[i][j]=1;
        dfs(1,0),redfs(1,0);
        for(int i=1;i<=n;i++)printf("%lld ",ans1[i]);
        printf("\n");
        for(int i=1;i<=n;i++)printf("%lld ",ans2[i]);
    }
}
signed main(){
    scanf("%lld%lld",&n,&k);
    for(int i=1;i<n;i++){
        int u,v;scanf("%lld%lld",&u,&v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    
    UpandDown::solve();
    return 0;
}

---

C- 小w的魔术扑克

题目描述

小w有\(k\)张魔术扑克，第i张魔术扑克有两面数值\(ai,bi\)(可能相等)，牌面的数值在\([1,n]\)。现在有q个询问，每个询问有两个整数\(l,r\)，询问是否能用若干张魔术扑克凑成\(l,l+1,..,r-1,r\)这个顺子，每张魔术扑克只能使用一面的值。

对于30%测试点，\(1<=n<=11\)，\(1<=k<=10\)，\(1<=q<=100\)。

对于60%测试点，\(1<=n，k<=50\)，\(1<=q<=500\)。

对于100%测试点，\(1<=n,k,q<=10^5\)，\(1<=l<=r<=n\)。

题解

标签：思维题，图论，并查集，离线询问，树状数组

30pts

二进制枚举。\(O(2^n*n)\)。

60pts

这种一一匹配的关系容易联想到二分图。令左边为\([1,n]\)的牌面，右边为魔术扑克的编号。建立两两联通关系，对于每个牌面l(\(l∈[1,n]\))，维护一个\(Ma[l]\)，表示若能打出l，则能打出的连续最右位置为Ma[l]，那么对于每个询问\((l,r)\)，只用判断\(Ma[l]>=r?可行:不可行\)。

如何维护？上面已经提到二分图了，如果直接枚举l,Ma[l]，然后再用匈牙利算法判一下，复杂度比较大。由于这个Ma显然具有单调性，考虑一边尺取，一边跑匈牙利算法。

代码如下，时间复杂度为\(O(N^3)\)，但是由于垃圾数据赛时是可以A了这题的。

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5;
int n,m,bf[N],gf[N];
int mark[N],Ma[N];
vector<int>g[N];
bool grab(int x){
    if(mark[x])return 0;
    mark[x]=1;
    for(int i=0;i<g[x].size();i++){
        int y=g[x][i];
        if(!bf[y]||grab(bf[y])){
            bf[y]=x;
            gf[x]=y;
            return 1;   
        }
    }
    return 0;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++){
        int x,y;scanf("%d%d",&x,&y);
        g[x].push_back(i);
        g[y].push_back(i);
    }
    for(register int l=1,r=0;l<=n;l++){
        bf[gf[l-1]]=0;
        r=max(r,l-1);
        memset(mark,0,sizeof(mark));
        while(r<n&&grab(r+1)){
            r++;
            memset(mark,0,sizeof(mark));
        }
        Ma[l]=r;
    }
    int q,l,r;scanf("%d",&q);
    for(register int i=1;i<=q;i++){
        scanf("%d%d",&l,&r);
        if(Ma[l]>=r)puts("Yes");
        else puts("No");
    }
}

100pts

数据范围加到\(10^5\)。把问题拎到图上去，建模。

对于一张魔术扑克\((a,b)\)，将编号为\((a,b)\)的节点先连一条无向边，这样会连出共\(k\)条边，可能会有重边，可能会形成多个联通块，每个联通块可能包含环也可能只是一棵树。现在对于询问\((l,r)\)，你需要将其中的若干条无向边变成有向边，也就是指定这条边指向两个端点中的一个，使得\((l,...,r)\)中的点的入度均不为0。

现在这个问题就是原问题套件衣服，不过现在到了图上看起来比较可做？。

引理1：对于无向连通图S。试将所有无向边改为有向边，当且仅当S中存在至少一个环(包括自环)时，能够使得S中的所有节点入度不为0。

证明：如果不存在环，那就是一棵普通的树，对于每条边，最优排布时应该是让每条边都指向深度较大的那个(指向儿子)，但最后对于根节点，它的入度为0，不合法。如果这时候树上出现了环，由人类智慧可知，会有多余的边剩给根节点，此时一定合法。

也就是说，当我们询问的\((l,r)\)时，只要存在一个不含环的联通块，满足这个联通块内的节点编号均被l,r覆盖，则不存在可行解能打出\([l,r]\)的顺子。

这就变成了一个简单的线段覆盖问题。接下来做法就很多了树状数组，set之类的，可以参考官方题解。下面给出一种较简洁的做法。

理一遍流程，在输出魔术扑克\((a,b)\)时，利用并查集维护联通块的信息，如果此前\(a,b\)已经在同一联通块，则合并这条边后，这个联通块就有了环，标记一下。连完边后，找出所有不含环的联通块，记该联通块内编号最大的节点为\(ma\)，编号最小的节点为\(mi\)，则视\([mi,..,ma]\)为一条线段，对于询问直接看\((l,r)\)会不会把某条线段覆盖了，如果会覆盖某条线段则输出No，反之Yes。看会不会把某条线段覆盖可以离线询问，然后对询问和原有线段都排个序扫一遍就好了。

时间复杂度为\(O(nlogn)\)。

代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
int n,m;
int fa[N],mi[N],ma[N],huan[N],cover[N];
int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
struct seg{
    int l,r,id;
}que[N];
vector<seg>g;
inline bool cmp(seg p,seg q){return p.r<q.r;}

int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)fa[i]=mi[i]=ma[i]=i;
    for(int i=1;i<=m;i++){
        int x,y;scanf("%d%d",&x,&y);
        int A=find(x),B=find(y);
        if(A==B)huan[A]=1;
        else{
            fa[A]=B;
            huan[B]|=huan[A];
            ma[B]=max(ma[B],ma[A]);
            mi[B]=min(mi[B],mi[A]);
        }
    }
    for(int i=1;i<=n;i++){
        if(find(i)==i&&!huan[i])g.push_back((seg){mi[i],ma[i],0});
    }
    int q;
    scanf("%d",&q);
    for(int i=1,a,b;i<=q;i++){
        scanf("%d%d",&a,&b);
        que[i]=(seg){a,b,i};
    }
    sort(g.begin(),g.end(),cmp);
    sort(que+1,que+q+1,cmp);
    for(int i=1,cur=0,maxl=0;i<=q;i++){
        while(cur<g.size()&&g[cur].r<=que[i].r){
            maxl=max(maxl,g[cur].l);cur++;
        }
        if(maxl>=que[i].l)cover[que[i].id]=1;
    }
    for(int i=1;i<=q;i++)puts(cover[i]?"No":"Yes");
}

原文地址：https://www.cnblogs.com/Tieechal/p/11770854.html