Codeforces Global Round 16

A.贪心

为了能够让中位数$a[mid]$更大，我们可以让中位数之前的数都为$0$

让中位数之后的数都尽量和中位数相等即可

#include<bits/stdc++.h>
using namespace std;

int main()
{
	int t;scanf("%d",&t);
	while (t--)
	{
		int n,s;
		scanf("%d %d",&n,&s);
		int mid = (n+1)/2;
		printf("%d\n",s/(n-mid+1));
	}
}

B.模拟

如果把$mex(0)==1,mex(1)==0,mex(01)==2$

为了最小，我们尽量把连续的$0$收集起来，把连续的$1$单独的看

但是有这种情况$01010101$

我们发现如果沿用上面的策略，我们得到的答案将会是$4$

很明显不正确

这时候，我们反念一想

最终的答案一定不会超过$2$

因为我们完全可以$mex$整个字符串

因此，最后只要和$mex$整个字符串取小即可

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+100;
char s[maxn];
int main()
{
	int t;scanf("%d",&t);
	while (t--)
	{
		scanf("%s",s+1);
		int n = strlen(s+1);
		int ans = 0;
		for (int i=1;i<=n;++i)if (s[i]==1||s[i]!=s[i-1])
		{
			if (s[i]=='0')ans++;
		}
		if (ans>2)ans = 2;
		printf("%d\n",ans);
	}
}

C.$dp$

算是$B$的进阶板了

很容易我们可以想到一个$dp$方案

$dp[i]$表示第$1$列到第$i$列的答案

$mex(l,r)$ 为计算第$l$列到第$r$列的$mex$

那么我们可以得到转移方程$dp[i]=max(dp[j]+mex(j+1,i))|j<i$

明显是$O(n^2)$的

下面我们考虑如何减小时间复杂度

$dp[i]=max(dp[j]+mex(j+1,i))|j<i$

我们真的要把$j$从$1$到$i-1$全部来一遍吗？

1. 如果第$i$列为$ \begin{matrix} 1 \\ 0 \end{matrix} $ 或$\begin{array}{c}0\\ 1\end{array}$ 我们只需$dp[i]=dp[i-1]+2$即可，

   因为$j$再往前$mex(j+1,i)$也不可能更大了反而$dp[j]$可能会更小

2. 如果第$i$列为$\begin{array}{c}1\\ 1\end{array}$ 我们只需$dp[i]=max(dp[i-1]+mex(i,i),dp[i-2]+mex(i-1,i))$

   若第$i-1$列存在$0$我们应该对$dp[i-2]+2$取大

   否则，我们也不该继续向前取了

   因为假设我们取到$j<i-2$ 第$j+1$列存在$0$

   $mex(j+1,i)==2$那么可以知道$mex(j+1,j+2)==2$

   $dp[j]+2==dp[j+2]+0==dp[i-2]+0$

3. 当第$i$列为$\begin{array}{c}0\\ 0\end{array}$时，和2一样我们只用$dp[i]=max(dp[i-1]+mex(i,i),dp[i-2]+mex(i-1,i))$即可

综上，$dp$公式为：$dp[i]=max(dp[i-1]+mex(i,i),dp[i-2]+mex(i-1,i))$

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+100;
char f1[maxn],f2[maxn];
int dp[maxn];
int n;
int cal(int l,int r)
{
	bool z=0,o=0;
	for (int i=l;i<=r;++i)
	{
		if (f1[i]=='1'||f2[i]=='1')o=1;
		if (f1[i]=='0'||f2[i]=='0')z=1;
	}
	if (!z)return 0;
	else if (!o)return 1;
	else return 2;
}
int main()
{
	int t;scanf("%d",&t);
	while (t--)
	{
		scanf("%d",&n);
		scanf("%s",f1+1);
		scanf("%s",f2+1);
		
		if (f1[1]!=f2[1])dp[1]=2;
		else if (f1[1]=='1')dp[1]=0;
		else dp[1]=1;
		
		for (int i=2;i<=n;++i)
			dp[i] = max(dp[i-1]+cal(i,i),dp[i-2]+cal(i-1,i));
		
		printf("%d\n",dp[n]);
	}
}

D1.逆序对

当$n$为$1$的时候

所有人就都是在同一排坐座位

仔细观察，题目说明，惊讶地发现这好像就是求一个正序对

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+100;
int a[maxn],d[maxn];
int n,m;
int main()
{
	int t;scanf("%d",&t);
	while (t--)
	{
		scanf("%d %d",&n,&m);
		for (int i=1;i<=m;++i)scanf("%d",&a[i]);
		int ans = 0;
		for (int i=1;i<=m;++i)
			for (int j=1;j<i;++j)if (a[j]<a[i])++ans;
		printf("%d\n",ans);
	}
}

D2.思维

$D1$的加强版了

此时$n$不再是$1$

我们先不急，我们先将$n\ast m$个人，按照他们的视力水平排一下序

即，按照$a[i]$的大小排序

我们可以说，他们的座位编号一定会符合他们的排序次序！

那么我们就可以$m$人分成一段，对每一段求正序对？

大致思路是正确的。但是有需要修改的地方。

我们看下面这个例子：

$n=2,m=4$

$a:11112122$

如果我们排序得到的序列为：

$64321578$

那么，得到的两排就是：$\begin{array}{cccc}6& 4& 3& 2\\ 1& 5& 7& 8\end{array}$

答案便为$0+6==6$

但是很明显，对于第二个排列我们可以这样排$1875$

答案为$0+3==3$

然后呢，我们还可以优化: $\begin{array}{cccc}4& 3& 2& 1\\ 6& 8& 7& 5\end{array}$

答案为$2$

如何满足我们这些条件呢？

我们可以这样排序，对于每个人，先按照他们的视力排序，视力相同的情况下，按照他们的编号排序

在计算正序对时，视力相同的人不计算

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+100;
int a[maxn],d[maxn];
int n,m;
int main()
{
	int t;scanf("%d",&t);
	while (t--)
	{
		scanf("%d %d",&n,&m);
		for (int i=1;i<=n*m;++i)scanf("%d",&a[i]);
		for (int i=1;i<=n*m;++i)d[i]=i;
		sort(d+1,d+1+n*m,[](int na,int nb)
		{
			if (a[na]==a[nb])return na<nb;
			return a[na]<a[nb];
		});
		int ans = 0;
		for (int k=0;k<n;++k)
			for (int i = k*m+1;i<=k*m+m;++i)
				for (int j=k*m+1;j<i;++j)
					if (d[j]<d[i]&&a[d[j]]<a[d[i]])++ans;
		printf("%d\n",ans);
	}
}

E.构造+思维+图论

首先我们意识到一点，如果我们把一个芽取下接在一个叶子节点上的话

我们会消灭这个叶子节点

当然，因为取掉了这个芽，该芽的父节点可能也会变成叶子节点

但是无论如何，这种操作使得叶子节点的减少成为了可能

然后，便没有了具体的思路了

通过在图纸上画画，我们得到了一种具体的构造方案

我们先找到一个叶子节点，然后不断对这棵树找芽。

找到芽就把芽连接到叶子节点上

最终，将会把所有的芽都堆到一棵树上！

然后，此刻树的叶子节点数量就是最终的答案。

实现之后，发现第一个样例没过
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8sDzRfOe-1632380847910)(https://espresso.codeforces.com/a8ab420b7ca4f310a11b4e815d2ee260498563d1.png)]

观察样例后发现，如果对于根$1$ 存在一个子节点是叶子节点，那么我们就使用这个叶子节点。

这样能更多消掉一个叶子节点。

改进这点后，仍然$WA$了

冷静思考

突然发现了这样的一张图：

如果我们先将图中的芽全部取出，然后再一个排一个地连接地话

似乎是更优的！

因此，我们的算法应当改进了，我们首先应当对整棵树进行解构

即，我们尽量取出他们的所有的芽！

然后再将这些芽一个拍一个地连接。

如果存在与根节点相连地叶子节点，那么顶部芽和该叶子节点连接，否则直接和根节点连接

最终答案就是这棵树的叶子节点数

这里，我的实现是，先将解析出来的芽和根节点连接，然后再将他们断开一个一个连接

这样的好处是，我们可以不必真正的连接，建造一棵新的树

芽断开和根节点连接时，总的叶子节点数可能+1也可能不变，具体要看该芽的父亲节点

然后最后答案减去芽的数量。如果不存在以根节点为根的叶子节点还要+1

#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5+100;
vector<int> G[maxn];
bool vis[maxn];
int du1[maxn],du2[maxn];
int fa[maxn];
int n;
void dfs(int u)
{
	for (int v:G[u])if (v!=fa[u])
	{
		fa[v]=u;
		dfs(v);
		++du2[u];
		if (du2[v]!=0)++du1[u];
	}
}
int main()
{
	int t;scanf("%d",&t);
	while (t--)
	{
		scanf("%d",&n);
		for (int i=0;i<=n;++i)
		{
			G[i].clear();
			vis[i]=du1[i]=du2[i]=0;
		}
		for (int i=1,u,v;i<n;++i)
		{
			scanf("%d %d",&u,&v);
			G[u].push_back(v);
			G[v].push_back(u);
		}
		dfs(1);
		int ans = 0;
		queue<int> que;
		for (int i=1;i<=n;++i)
		{
			if (du2[i]==0)++ans;
			else if (du1[i]==0)
				que.push(i);
		}
		int res = 0;
		while (!que.empty())
		{
			int u = que.front();
			que.pop();
			if (u==1)continue;
			++res;
			--du1[fa[u]];
			--du2[fa[u]];
			if (fa[u]==1)continue;
			if (du2[fa[u]]==0)
			{
				++ans;
				--du1[fa[fa[u]]];
				if (du1[fa[fa[u]]]==0)
				{
					que.push(fa[fa[u]]);
				}
			}
			else if (du1[fa[u]]==0)
			{
				que.push(fa[u]);
			}
		}
		if (res==0)printf("%d\n",ans);
		else
		{
			--res;
			for (int v:G[1])if (du2[v]==0)
			{
				++res;
				break;
			}
			printf("%d\n",ans-res);
		}
	}
}