7月26日模拟赛

1.树染色问题(tree.cpp)

50分思路：

 按照题意建树，用并查集区分各个连通块，统计两种颜色的连通块的个数，答案即为二者中的最小值。

#include<bits/stdc++.h>
#define in read()
#define MAXN 200050
#define MAXM MAXN*2
using namespace std;

int n;
int nex[MAXM],first[MAXM],to[MAXM],tot=0;
int fa[MAXN],col[MAXN];

inline int read(){
	int x=0,f=1;char c=getchar();
	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
	while(isdigit(c)){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
	return x*f;
}

inline void addedge(int u,int v){
	nex[++tot]=first[u];
	first[u]=tot;
	to[tot]=v;
}

int getfa(int x){
	if(fa[x]==x)return fa[x];
	fa[x]=getfa(fa[x]);
	return fa[x]; 
}

void combine(int x,int y){
	x=getfa(x),y=getfa(y);
	if(x!=y)fa[y]=x; 
}

void dfs(int u,int fa){
	for(int e=first[u];e;e=nex[e]){
		int v=to[e];
		if(v==fa)continue;
		if(col[v]==col[u])combine(u,v);
		dfs(v,u);
	}
}

int main(){
//	freopen("tree.in","r",stdin);
//	freopen("tree.out","w",stdout);
	n=in;
	for(int i=1;i<=n;i++)col[i]=in;
	for(int i=1;i<n;i++){
		int u=in,v=in;
		addedge(u,v);
		addedge(v,u);
	}
	for(int i=1;i<=n;i++)fa[i]=i; 
	dfs(1,0); 
	sort(fa+1,fa+n+1);
	int tott=unique(fa+1,fa+n+1)-fa-1;
	int cnt1=0,cnt2=0;
	for(int i=1;i<=tott;i++)
		if(col[fa[i]]==0)cnt1++;
		else cnt2++;
	cout<<min(cnt1,cnt2)<<'\n';
	return 0;
} 

100分做法：

 上诉做法显然是有漏洞的，举一个简单的例子，如下图：

 如果按照50分做法来看，答案应该是4。而实际上答案显然应该是2。

 我们需要思考正解，先看一个例子：

 如果我们按照层数一层一层地修改颜色，那么最后的答案就是这颗树的层数-1。
 进一步思考一下，我们可以对修改方式进行一个分析：
 1.当一层只有有一个点需要修改时，只需要修改这一个就可以实现上下两层合并。
 2.当一层有两个点需要修改时，修改这两个点所需的代价与一层一层修改所需的代价是一样的。
 3.当一层中有大于三个点需要修改时，修改三个点的代价为3，一层一层修改的代价为2，显然需要选择后者。

 我们按照这个思路，对上图重新进行分析，显然我们可以得出一个更小的方案：
 1.修改第二层的两个点。
 2.修改第四层。
 3.单独修改第五层的点。
 这样我们所得到的最小值就是4。

 总结一下，我们优化方案就有了两种，一种是链的情景，另一种就是上诉提及的原始思路（返回dep值）。

 根据这两点，我们就可以直接想到，我们直接选树的直径的中心作为根节点，进行第一种操作，同时这种操作不会出现单点修改最优的情况。

 具体证明如下，要出现单点修改的情况，则必须满足如下图所示的情况。那么我们所找的点（图中最高点）就不是树的直径的中心。因此，一旦选择树的直径的中心，不可能再出现比这个更优的情况了。到此，证明完毕。

 分析到这里，我们的答案就应该是树的直径长度的一半（向下取整）。

 我们还可以在代码中先求出各个连通块，在进行缩点，这样可以有效减小询问次数。

#include<bits/stdc++.h>
#define in read()
#define MAXN 200050
using namespace std;
int n,col[MAXN],a[MAXN],b[MAXN],fa[MAXN],dep[MAXN],rt=0;
vector<int>E[MAXN];
inline int read(){
	int x=0,f=1;char c=getchar();
	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
	while(isdigit(c)){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
	return x*f;
}
int getfa(int x){
	if(fa[x]==x)return fa[x];
	fa[x]=getfa(fa[x]);
	return fa[x];
}
inline void combine(int x,int y){
	x=getfa(x),y=getfa(y);
	if(x!=y)fa[y]=x;
}
void dfs(int u,int fa){
	for(int i=0;i<E[u].size();i++){
		int v=E[u][i];
		if(v==fa)continue;
		if(col[u]==col[v]){combine(u,v);}
		dfs(v,u);
	} 
}
void dfs1(int u,int fa){
	dep[u]=dep[fa]+1;
	if(dep[u]>dep[rt])rt=u;
	for(int i=0;i<E[u].size();i++){
		int v=E[u][i];
		if(v==fa)continue;
		dfs1(v,u);
	}
}
int main(){
//	freopen("tree.in","r",stdin);
//	freopen("tree.out","w",stdout);
	n=in;
	for(int i=1;i<=n;i++)col[i]=in;
	for(int i=1;i<=n-1;i++){
		a[i]=in,b[i]=in;
		E[a[i]].push_back(b[i]),E[b[i]].push_back(a[i]); 
	}
	for(int i=1;i<=n;i++)fa[i]=i;
	dfs(1,0);
	for(int i=1;i<=n;i++)E[i].clear();
	for (int i=1;i<n;i++){
		int x=fa[a[i]],y=fa[b[i]];
		if (x!=y)E[x].push_back(y),E[y].push_back(x);//缩点 
	}
	dfs1(1,0);
	int x=rt;rt=0;
	memset(dep,0,sizeof(dep));
	dfs1(x,0);
	cout<<dep[rt]/2<<'\n';
	return 0;
} 

3.最优化问题（maximize.cpp）

10分暴力

 直接暴力枚举所有可能的情况与答案打擂台比较即可。（类似算组合的枚举）

#include<bits/stdc++.h>
#define in read()
#define MAXN 5050
using namespace std;
int n,k,a[MAXN],b[MAXN],ans=-114514;
bool vis[MAXN]={false};

inline int read(){
	int x=0,f=1;char c=getchar();
	while(!isdigit(c)){if(c=='-')f=-1;c=getchar();}
	while(isdigit(c)){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
	return x*f;
}

void dfs(int index,int start){
	if(index==n-k+1){
		int cnt=0;
		for(int i=1;i<=n-k;i++)if(b[i]==i)cnt++;
		ans=max(ans,cnt);
		return;
	}
	for(int i=start;i<=n;i++){
		b[index]=a[i];
		dfs(index+1,i+1); 
		b[index]=0;
	}
}

int main(){
//	freopen("1.in","r",stdin);
//	freopen("1.out","w",stdout);
	n=in,k=in;
	for(int i=1;i<=n;i++)a[i]=in;
	for(int i=1;i<=n;i++)dfs(1,1);
	cout<<ans<<'\n';
	return 0;
}

100分正解

 先来分析考虑一个数何时产生贡献：如果一个数能够通过一定删数的方式达到最优方案，那么这个数$a_i$起初一定是大于等于$i$的。产生贡献的方法如下。

 同时，我们也可以显然地看出，图中$a[i+x]$之后的数想要产生贡献，那么这个数必须要大于$i$（这个很好理解）。

 对于每一个$i$而言，我们只能越删越多，且能产生贡献的数只能越来越大。而最后的答案只能从某个前缀转移。二维偏序就不难想到了。

 假设上图中左边的数$a_i$的大小是$v_1$，需要删除的数为$v_2$，右边的数的大小为$v_1^{\prime }$，需要删除的数为$v_2^{\prime }$，此时我们需要满足$v_1^{\prime }>v_1$并且$v_2^{\prime }>v_2$。

树状数组：下标：删i个数
数的大小（排序），从小到大加入，查询需要删的数的前缀。