2024ICPC成都题解

原创已于 2025-04-28 16:01:23 修改 · 782 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #图论 #深度优先

于 2025-04-28 16:00:15 首次发布

XCPC题解专栏收录该内容

17 篇文章

订阅专栏

文章目录

L. Recover Statistics(签到)
J. Grand Prix of Ballance(模拟签到)
A. Arrow a Row(构造)
B. Athlete Welcome Ceremony(线性dp)
G. Expanding Array(打表+结论)
I. Good Partitions(线段树)
E. Disrupting Communications(换根dp+LCA倍增)
K. Magical Set(费用流)

题目链接

L. Recover Statistics(签到)

J. Grand Prix of Ballance(模拟签到)

在这里插入图片描述

struct Node{
    int val,id;
    bool operator<(const Node&tmp)const{
        if(val!=tmp.val)return val>tmp.val;
        return id<tmp.id;
    }
};
void solve(){
    int n,m,q;
    cin>>n>>m>>q;
    vector<int> cnt(n+1,m),ans(m+1);
    map<int,bool> mp[n+1];
    int now=0;
    while(q--){
        int op,x,y;
        cin>>op>>x;
        if(op==1){
            now=x;
            continue;
        }
        cin>>y;
        if(now!=y)continue;
        if(mp[y].count(x))continue;
        if(op==2)ans[x]+=cnt[y]--;
        mp[y][x]=1;
    }
    vector<Node> node;
    for(int i=1;i<=m;i++)node.push_back({ans[i],i});
    sort(node.begin(),node.end());
    for(auto [x,y]:node)cout<<y<<" "<<x<<"\n";
}

A. Arrow a Row(构造)

在这里插入图片描述

int main()
{
	int t;cin>>t;
	while(t--){
		vector< pair<int,int> >ans;
		string s;
		cin>>s;
		int n=s.length();
		int f=0;
		for(f=n-1;s[f]=='>'&&f>=0;f--);
		if(s[0]=='-'||n-f<4||f<0){
			puts("No");
			continue;
		}
		for(int i=n-1;i>=f+3;i--) ans.push_back(make_pair(1,i+1));
		for(int i=1;i<=f;i++){
			if(s[i]=='>') ans.push_back(make_pair(i+1,f+4-i));
		}
		printf("Yes %d\n",ans.size());
		for(int i=0;i<ans.size();i++) printf("%d %d\n",ans[i].first,ans[i].second);
	}
	return 0;
}

B. Athlete Welcome Ceremony(线性dp)

在这里插入图片描述

很经典的线性dp，定义 $f_{i,j,k,0/1/2}$ 表示考虑前 $i$ 位，问号中有 $j$ 个 $a$ , $k$ 个 $b$ ，当前选 $a / b / c$ 的方案数
然后询问的话做一个三维前缀和
复杂度 $O(n^3+q)$
复盘：以后写滚动数组再也不另开空间了，在这题直接tle了

#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define LL long long
#define F first
#define S second
#define TR tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
// typedef pair<int,int> PII;
const int N=1e6+10,M=3e4+10;
// const int INF=1e18;
// const int mod=998244353;
const int mod=1e9+7;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
void add(LL &x,LL y){
    x+=y;
    if(x>=mod)x-=mod;
}
void sub(LL &x,LL y){
    x-=y;
    if(x<0)x+=mod;
}
void solve(){
    int n,q;
    cin>>n>>q;
    string s;
    cin>>s;
    s=" "+s;
    vector dp(2,vector (n+1,vector (n+1,vector<LL>(3))));
    int cnt=0;
    if(s[1]!='?'){
        if(s[1]=='a')dp[1][0][0][0]=1;
        if(s[1]=='b')dp[1][0][0][1]=1;
        if(s[1]=='c')dp[1][0][0][2]=1;
    }
    else{
        cnt++;
        dp[1][1][0][0]=1;
        dp[1][0][1][1]=1;
        dp[1][0][0][2]=1;
    }
    for(int i=2;i<=n;i++){
        if(s[i]=='?')cnt++;
        for(int j=0;j<=cnt;j++){
            for(int k=0;k+j<=cnt;k++){
                for(int x=0;x<3;x++)dp[i&1][j][k][x]=0;
            }
        }
        for(int j=0;j<=cnt;j++){
            for(int k=0;k+j<=cnt;k++){
                for(int x=0;x<3;x++){
                    if(s[i]!='?'){
                        if(s[i]=='a'&&x!=0)add(dp[i&1][j][k][0],dp[i-1&1][j][k][x]);
                        if(s[i]=='b'&&x!=1)add(dp[i&1][j][k][1],dp[i-1&1][j][k][x]);
                        if(s[i]=='c'&&x!=2)add(dp[i&1][j][k][2],dp[i-1&1][j][k][x]);
                    }
                    else{
                        if(j&&x!=0)add(dp[i&1][j][k][0],dp[i-1&1][j-1][k][x]);
                        if(k&&x!=1)add(dp[i&1][j][k][1],dp[i-1&1][j][k-1][x]);
                        if(x!=2)add(dp[i&1][j][k][2],dp[i-1&1][j][k][x]);
                    }
                }
            }
        }
    }
    vector  f(n+1,vector (n+1,vector<LL>(n+1)));
    for(int i=0;i<=cnt;i++){
        for(int j=0;i+j<=cnt;j++){
            for(int k=0;k<3;k++){
                add(f[i][j][cnt-i-j],dp[n&1][i][j][k]);
            }
        }
    }
    for(int i=0;i<=n;i++){
        for(int j=0;j<=n;j++){
            for(int k=0;k<=n;k++){
                if(i>=1)add(f[i][j][k],f[i-1][j][k]);
                if(j>=1)add(f[i][j][k],f[i][j-1][k]);
                if(k>=1)add(f[i][j][k],f[i][j][k-1]);
                if(i>=1&&j>=1)sub(f[i][j][k],f[i-1][j-1][k]);
                if(i>=1&&k>=1)sub(f[i][j][k],f[i-1][j][k-1]);
                if(j>=1&&k>=1)sub(f[i][j][k],f[i][j-1][k-1]);
                if(i>=1&&j>=1&&k>=1)add(f[i][j][k],f[i-1][j-1][k-1]);
            }
        }
    }
    while(q--){
        int x,y,z;
        cin>>x>>y>>z;
        cout<<f[x][y][z]<<"\n";
    }
} 
signed main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1;
    // cin>>T;
    while(T--)solve();
    return 0;
}

G. Expanding Array(打表+结论)

在这里插入图片描述

打表发现两个数生成的数不会超过 $8$ ，因此直接暴力dfs统计，如果一对数已经出现则退出

map<pair<int,int> ,int> mp;
set<int> s,c;
void dfs(int a,int b)
{
    if(c.size()>=8)return;
	int c1=a&b;c.insert(c1);
	int c2=a^b;c.insert(c2);
	int c3=a|b;c.insert(c3);
	if(!mp[{min(a,c1),max(a,c1)}]) mp[{min(a,c1),max(a,c1)}]=1,dfs(a,c1);
	if(!mp[{min(a,c2),max(a,c2)}]) mp[{min(a,c2),max(a,c2)}]=1,dfs(a,c2);
	if(!mp[{min(a,c3),max(a,c3)}]) mp[{min(a,c3),max(a,c3)}]=1,dfs(a,c3);
	if(!mp[{min(b,c1),max(b,c1)}]) mp[{min(b,c1),max(b,c1)}]=1,dfs(b,c1);
	if(!mp[{min(b,c2),max(b,c2)}]) mp[{min(b,c2),max(b,c2)}]=1,dfs(b,c2);
	if(!mp[{min(b,c3),max(b,c3)}]) mp[{min(b,c3),max(b,c3)}]=1,dfs(b,c3);
}
int a[100010];
int main()
{
    int n;cin>>n;
    for(int i=1;i<=n;i++) scanf("%d",&a[i]),s.insert(a[i]);
    
    for(int i=1;i<n;i++) 
	{
		mp.clear();
		c.clear();
        dfs(a[i],a[i+1]);
        for(auto it:c)s.insert(it);
	}
	cout<<s.size(); 
	return 0;
}

I. Good Partitions(线段树)

在这里插入图片描述

将数组划分成若干个不下降序列
$a_i \gt a_{i+1}$ ，我们称 $i$ 是一个断点，则断点序列为 $[a, b, c, ...]$ ，则 $\gcd(a,b-a,c-b,...)$ 的因数就是答案，但是 $\gcd(a,b-a,c-b,...)$ 不好维护，注意到 $\gcd(a,b)=\gcd(a,b-a)$ ，因此等价于求 $\gcd(a,b,c,..)$ ，用线段树维护即可，因数个数可以调和级数预处理
复杂度 $\log n)$

代码就不写了，vp的时候写了个很复杂的线段树直接维护 $\gcd(a,b-a,c-b,..)$

E. Disrupting Communications(换根dp+LCA倍增)

在这里插入图片描述

这题是很经典的缝合题，换根和lca倍增预处理都很典
但是卡了个 $\mod 998244353=0$ ，导致赛场上过的比网络流少？
考虑 $u, v$ 的路径， $l c a (u, v) = l c a$ ，以 $1$ 为根，那么答案统计可以分为，
- 包括 $l c a$ 的连通子图
- $u$ 到 $l c a$ 路径上的点，只考虑该点的子树的贡献的和(不包括 $l c a$ )
- 同理， $v$ 到 $l c a$ 的
那么很明显需要做一次换根dp
考虑以 $1$ 为根，定义 $f_i$ 表示只考虑 $i$ 子树内，包括 $i$ 的连通子图，则对于每个儿子可以选与不选， $f_u =\prod (f_v+1)$
考虑换根，定义 $g_i$ 为以 $i$ 为根，包括 $i$ 的连通子图，则 $g_v=f_v \cdot (\frac{g_u}{f_v+1}+1)$
那么换完根后就求出了对应的数组，lca倍增预处理即可
询问的时候就倍增往上跳，注意lca处的 $f$ 不需要统计(因为g数组已经统计了)，因此需要减去两次这个贡献
最大的坑点，换根的时候会存在 $f_v+1=998244353$ ，此时 $f_v+1$ 没有逆元，不能直接求，因此需要特殊处理这部分
复杂度 $\log n)$

int par[N][40],sum[N][40],dep[N],f[N],g[N];
vector<int> adj[N];
int qpow(int a,int b){
    int ans=1;
    for(;b;b>>=1){
        if(b&1)ans=ans*a%mod;
        a=a*a%mod;
    }
    return ans;
}
void dfs(int u,int fa){
    dep[u]=dep[fa]+1;
    par[u][0]=fa;
    for(int i=1;i<=__lg(dep[u]);i++)par[u][i]=par[par[u][i-1]][i-1];
    for(auto v:adj[u]){
        dfs(v,u);
    }
}
int lca(int x,int y){
    if(dep[x]<dep[y])swap(x,y);
    while(dep[x]>dep[y]){
        x=par[x][(int)__lg(dep[x]-dep[y])];
    }
    if(x==y)return x;
    for(int i=__lg(dep[x]);i>=0;i--){
        if(par[x][i]!=par[y][i])x=par[x][i],y=par[y][i];
    }
    return par[x][0];
}
void dfs_u(int u){
    f[u]=1;
    if(adj[u].size()==0){
        return;
    }
    for(auto v:adj[u]){
        dfs_u(v);
        (f[u]*=(f[v]+1))%=mod;
    }
}
void dfs_d(int u,int top){
    g[u]=f[u]*(top+1)%mod;
    vector<int> tmp;
    for(int i=0;i<adj[u].size();i++)tmp.push_back((f[adj[u][i]]+1));
    vector<int> pre(tmp.size()+1),suf(tmp.size()+1);
    for(int i=0;i<tmp.size();i++)pre[i]=(i==0?1:pre[i-1])*tmp[i]%mod;
    for(int i=tmp.size()-1;i>=0;i--)suf[i]=(i==tmp.size()-1?1:suf[i+1])*tmp[i]%mod;
    for(int i=0;i<adj[u].size();i++){
        int x=(i==0?1:pre[i-1])*(i==tmp.size()-1?1:suf[i+1])%mod*(top+1)%mod;
        dfs_d(adj[u][i],x);
    }
};
int get(int u,int d){
    int ans=f[u];
    for(int i=30;i>=0;i--){
        if(d>>i&1){
            (ans+=sum[u][i])%=mod,u=par[u][i];
        }
    }
    return ans;
}
void solve(){
    int n,q;
    cin>>n>>q;
    for(int i=2;i<=n;i++){
        int x;
        cin>>x;
        adj[x].push_back(i);
    }
    dfs(1,0);
    dfs_u(1);
    dfs_d(1,0);
    for(int i=1;i<=n;i++)sum[i][0]=f[par[i][0]];
    for(int j=1;j<=30;j++){
        for(int i=1;i<=n;i++)sum[i][j]=(sum[i][j-1]+sum[par[i][j-1]][j-1])%mod;
    }
    while(q--){
        int u,v;
        cin>>u>>v;
        int LCA=lca(u,v);
        int ans=((g[LCA]-2*f[LCA]%mod)%mod+mod)%mod;
        (ans+=get(u,dep[u]-dep[LCA]))%=mod;
        (ans+=get(v,dep[v]-dep[LCA]))%=mod;
        cout<<ans<<"\n";
    }
    for(int i=0;i<=n;i++){
        adj[i].clear();
        memset(par[i],0,sizeof par[i]);
        memset(sum[i],0,sizeof sum[i]);
        dep[i]=f[i]=g[i]=0;
    }
}

K. Magical Set(费用流)

在这里插入图片描述

对于一个数 $x=p_1^{k_1}p_2^{k_2}p_3^{k_3}...$ ，假设初始 $K=\sum k_i$ ，最终的数为 $K'=\sum k_i$ ,则操作次数最大肯定是 $K - K^{'}$

要求每次集合的数互异，那么我们只需要保证最终集合互异即可

进而转化为二分图匹配问题，左边点是 $a_i$ ，右边是可能的因数，匹配费用为 $K - K^{'}$

变成一个最大费用最大流问题，连边，套板子即可

注意本题卡任意的类似EK的单路增广算法，需要使用类似zkw费用流这样的多路增广才能过

int h[N],e[M],f[M],w[M],ne[M],idx;
int dis[N],cur[N];//d表示最短距离,cur为当前弧
int n,m,S,T;
bool vis[N];
int height[N];// 势能函数
vector<int> dot;// 点数
void add(int a,int b,int c,int d){
    e[idx]=b,f[idx]=c,w[idx]=d,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,w[idx]=-d,ne[idx]=h[b],h[b]=idx++;
}
bool dijk(){
    for(auto &i:dot)dis[i]=INF,cur[i]=h[i];
	priority_queue<PII,vector<PII>,greater<>> pq;
	dis[S]=0;
    pq.emplace(0,S);
    while(!pq.empty()){
		auto [d,u]=pq.top();
		pq.pop();
		if(dis[u]!=d)continue;
		for(int i=h[u];~i;i=ne[i]){
			int v=e[i];
			if(f[i]&&dis[v]>d+height[u]-height[v]+w[i]){
				dis[v]=d+height[u]-height[v]+w[i];
				pq.emplace(dis[v],v);
			}
		}
    }
    return dis[T]!=INF;
}   
int find(int u,int limit){
	if(!limit||u==T)return limit;
	int flow=0;
	vis[u]=1;
    for(int &i=cur[u];~i&&flow<limit;i=ne[i]){
        int v=e[i];
        if(dis[v]==dis[u]+height[u]-height[v]+w[i]&&f[i]&&!vis[v]){
            int t=find(v,min(f[i],limit-flow));
            f[i]-=t,f[i^1]+=t,flow+=t;
			if(flow==limit)break;
        }
    }
	vis[u]=0;
    return flow;
}
void mcmf(int &flow,int &cost){
	flow=cost=0;
	int r;
	while(dijk()){
		int r=find(S,INF);
		flow+=r;
		for(auto &i:dot)height[i]+=dis[i];
		cost+=height[T]*r;
	}
}
void solve(){
	int n;
	cin>>n;
	unordered_map<int,int> mp;
	int tot=n;
	auto id=[&](int x){
		if(!mp.count(x))mp[x]=++tot;
		return mp[x];
	};
	vector<int> a(n+1);
	memset(h,-1,sizeof h);
	for(int i=1;i<=n;i++){
		cin>>a[i];
		vector<PII> tmp;
		int x=a[i],all=0;
		for(int j=2;j*j<=x;j++){
			if(x%j==0){
				int cnt=0;
				while(x%j==0)x/=j,cnt++;
				tmp.emplace_back(j,cnt);
				all+=cnt;	
			}
		}
		if(x>1)tmp.emplace_back(x,1),all++;
		vector<array<int,2>> edge;
		function<void(int,int,int)> dfs=[&](int x,int c,int sum){
			if(x==tmp.size()){
				edge.push_back({sum,all-c});
				return;
			}
			auto &[p,cnt]=tmp[x];
			int y=1;
			for(int j=0;j<=cnt;j++,y*=p)dfs(x+1,c+j,y*sum);
		};
		sort(edge.begin(),edge.end());
		dfs(0,0,1);
		for(int j=0;j<edge.size()&&j<n;j++)add(i,id(edge[j][0]),1,-edge[j][1]);
	}
	S=0,T=++tot;
	for(int i=0;i<=tot;i++)dot.push_back(i);
	for(int i=1;i<=n;i++)add(S,i,1,0);
	for(int i=n+1;i<tot;i++)add(i,T,1,0);
	int flow,cost;
	mcmf(flow,cost);
	cout<<-cost<<"\n";
}