2026ICPC成都补题题解 CI

C

一个非常精彩的问题。

考虑不设任何限制的情况,每个位置都可以选择 \(+0\) 或者 \(+1\),后面的 \(n-1\) 个位置是没有限制的,于是答案数是 \(2^{n-1}\);

一个观察是:

选择让一个位置 \(+1\),等价于让下一个检查点的值加上当前位置到检查点的距离;那么可以将两个检查点 \((p_{i-1},p_i]\) 中间的点的贡献分别是 \(+1,+2,+3,+....\)

这道题实际上基本上就做完了。

第二个观察是:如果确定前面已经选择了几个位置加 \(1\),那么在过后续检查点时,和前面选择的位置具体是哪里无关,只与前面选择的数量有关。

考虑设立转移方程: \(f_{i,j}\) 表示恰好已经通过了 \(i\) 个检查点,且当前选择了 \(j\) 个数,这样的方案数;再考虑设计一下 \(dp_{i,j,k}\) 表示从 \([0,i]\) 中恰好选择了 \(j\) 个数,且最终加起来总和为 \(k\) 的方案数。 \(f_{i,j}->f_{i+1,j+c,need}\),\(need\) 表示在这两段检查点中还需要选取的数的总和,其中 \(need=lim_{i}-lim_{i-1}-(lim_i-lim_{i-1})*j\),含义是:我当前这一段的总和肯定只能从上一段的前缀和加来,而且上一段已选的数对我的区间内的每个数都会产生贡献,这样转移时间复杂度实际上是 \(O(n^2)\) 的。

#include<bits/stdc++.h>
#define int long long 
#define fi first 
#define se second
#define pb push_back
using ll=long long;
using namespace std;
typedef pair<int,int>pii;//限制
//你需要构造一个数组,满足一些性质
//我会了 考虑 g[i][j] 表示前 i 个位置选出 总和 为 j 的方案数 背包
//考虑将贡献拆成一段一段去做,然后就做完了
const int N=101;
const int M=1e4+1;
const int mod=998244353;
int dp[N][N][M];//前 i 个位置选取了 j 个,总和是 k 的方案数
ll pw2[N];
void mo(int &x){
    x=(x%mod+mod)%mod;
}
void init(){
    dp[0][0][0]=1;
    int n=100;
    pw2[0]=1;
    for(int i=1;i<=n;i++)pw2[i]=pw2[i-1]*2%mod;
    for(int i=1;i<=n;i++){
        for(int j=0;j<=i;j++){
            for(int k=0;k<=i*(i+1)/2;k++){
                dp[i][j][k]=dp[i-1][j][k];
                if(j-1>=0&&k-i>=0){
                    dp[i][j][k]=dp[i][j][k]+dp[i-1][j-1][k-i];
                    mo(dp[i][j][k]);
                }
            }
        }
    }
    //打印一些比较小的 dp 看看
}
void Silverwolf(){
    int n,m;
    cin>>n>>m;
    if(m==0)return cout<<pw2[n-1]<<'\n',void();//如果没有限制的话 后面的 n-1 个位置直接乱搞
    bool ok=true;//有解
    vector<pii>lim={{1,0}};
    for(int i=1;i<=m;i++){
        int p,v;
        cin>>p>>v;
        if(p==1){
            if(v)ok=false;
        }else{
            lim.pb({p,v});//限制
        }
    }
    if(!ok)return cout<<0<<'\n',void();
    int sz=lim.size()-1;
    //考虑 f[i][j] 表示 当前已经通过了 i 个检查点,且前面的检查点中选取了 j 个数字的方案数。
    vector<vector<int>>f(n+1,vector<int>(n+1,0));
    vector<vector<int>>vis(n+1,vector<int>(n+1,0));
    f[0][0]=1;
    //然后做一个类似 bfs 的 dp 转移
    queue<pii>que;
    que.push({0,0});
    while(que.size()){
        auto [i,j]=que.front();
        //要转移到 下一个转移点
        que.pop();
        if(i==sz)continue;//这就是最后一个检查点
        if(f[i][j]==0)continue;
        int num=lim[i+1].fi-lim[i].fi;//到下一个检查点之前还有多少个数字能选择
        int need=lim[i+1].se-j*num-lim[i].se;//因为前面选的数字已经对当前位置造成了一些贡献
        if(need<0)continue;
        for(int c=0;c<=num;c++){
            //枚举到下一个检查点之前选择的数字
            if(need<=1e4&&dp[num][c][need]){
                f[i+1][j+c]=(f[i+1][j+c]+1ll*f[i][j]*dp[num][c][need])%mod;
                mo(f[i+1][j+c]);
                if(!vis[i+1][j+c]){
                    vis[i+1][j+c]=1;
                    que.push({i+1,j+c});
                }
            }
        }
    }
    int res=0;
    for(int c=0;c<=n;c++){
        res+=f[sz][c];
        mo(res);
    }
    int pos=n-lim[sz].fi;//随便放
    res=1ll*res*pw2[pos]%mod;
    cout<<res<<'\n';
}
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    init();
    int T;cin>>T;while(T--)
    Silverwolf();
    return 0; 
}

I

一个相当漂亮的问题。

不妨考虑将所有连通块一起做 bfs,处理出一个 bfs 序;

然后点权放 \(a_i=dfn_i+dfn_{fa_i}\)。

不难发现这个东西是严格递增的,我们做完了。

简单证明一下:

对于 \(i<j\),\(dfn_i<dfn_j,dfn_{fa_i}\leq dfn_{fa_j}\),于是 \(a_i<a_j\);

做完了。

#include<bits/stdc++.h>
#define pb push_back
#define fi first 
#define se second
using ll=long long;
using namespace std;
const ll inf=1e12+99;
const ll MAXD=1e18;
typedef pair<ll,ll>pii;
void Cat(){
    int n,m;
    cin>>n>>m;
    vector<vector<int>>e(n+1);
    for(int i=1;i<=m;i++){
        int u,v;
        cin>>u>>v;
        e[u].pb(v);
        e[v].pb(u);
    }
    vector<int>fa(n+1,0);
    vector<int>vis(n+1,0);
    vector<int>dfn(n+1,0);
    int cnt=0;
    // vector<int>fa(n+1,0);
    auto dfs=[&](auto &&dfs,int u,int f)->void{
        fa[u]=f;
        for(int v:e[u]){
            if(v==f)continue;
            dfs(dfs,v,u);
        }
    };
    
    auto bfs=[&]()->void{
        queue<int>que;
        for(int i=1;i<=n;i++){
            if(fa[i]==0){
                que.push(i);
                vis[i]=1;
                dfn[i]=++cnt;
            }
        }
        while(que.size()){
            auto u=que.front();
            que.pop();
            for(int v:e[u]){
                if(vis[v])continue;
                vis[v]=1;
                fa[v]=u;
                que.push(v);
                dfn[v]=++cnt;
            }
        }
    };
    for(int i=1;i<=n;i++){
        if(!fa[i])dfs(dfs,i,0);
    }
    bfs();
    for(int i=1;i<=n;i++){
        cout<<dfn[i]+dfn[fa[i]]<<' ';
    }
    cout<<endl;
}
void Dog(){
    int n;
    cin>>n;
    vector<pii>a(n+1);
    vector<int>fa(n+1,0);
    vector<int>rt;
    map<int,int>mp;
    for(int i=1;i<=n;i++){
        cin>>a[i].fi;
        a[i].se=i;
    }
    
    sort(a.begin()+1,a.end());
    vector<pii>edg;
    
    for(int i=1;i<=n;i++){
        int j=a[i].fi-i;
        if(j==0)continue;
        int u=a[i].se;
        int v=a[j].se;
        edg.pb({u,v});
    }
    cout<<edg.size();
    for(auto [u,v]:edg){
        cout<<"\n"<<u<<' '<<v;
    }
    cout<<endl;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    string str;
    cin>>str;
    if(str=="cat"){
        int T;cin>>T;while(T--)
        Cat();
    }else{
        int T;cin>>T;while(T--)
        Dog();
    }
    
    return 0;
}

导航