Educational Codeforces Round 97 div2

最新推荐文章于 2020-10-29 09:18:44 发布

zhangjianjunab

最新推荐文章于 2020-10-29 09:18:44 发布

阅读量167

点赞数

本文链接：https://blog.csdn.net/zhangjianjunab/article/details/109329338

版权

前言

比赛列表

我的天啊，上次刚说有个简单的，现在这场比赛就打到我心态爆炸QAQ。

上次还能勉强五五开，这次ZWQ和CLB直接把我摁在地上锤了QAQ，QAQ果然我只能做简单题吗QAQ。

A

题意：相当于给你一个区间 $[l, r]$ ，要求选择一个数字 $a$ 使得 $∀x∈[l,r],x\mod a≥\frac{a}{2}$ 。

题解：看样例，提示的十分明显， $[3, 4]$ 选 $5$ ，不妨考虑 $a = r + 1$ ，这样的话区间只要 $l≥\frac{r+1}{2}$ 即可，但是呢，为什么不存在比这个更加优秀的呢？不难发现，如果 $a > r$ ，那么 $a$ 越大， $l$ 的下限也越大， $a = r + 1$ 是最优秀的。

在考虑 $a \leq r$ ，不难发现， $l≥\left \lfloor \frac{r}{a} \right \rfloor*a$ （不是严格下限）

当 $a≥\left \lfloor \frac{r+2}{2} \right \rfloor$ ， $l≥a≥\left \lfloor \frac{r+2}{2} \right \rfloor≥\frac{r+1}{2}$ ，当 $a<\left \lfloor \frac{r+2}{2} \right \rfloor$ ，因为 $l$ 的下限要小于 $l≥\frac{r+1}{2}$ ，所以 $[\left \lceil \frac{r+1}{2} \right \rceil,r]$ 区间内不存在任何被 $a$ 整除的数字，所以 $a>r-\left \lceil \frac{r+1}{2} \right \rceil≥r-\frac{r+1}{2}≥\frac{r-1}{2}≥\left \lfloor \frac{r-1}{2} \right \rfloor$ ，所以 $a≥\left \lfloor \frac{r+1}{2} \right \rfloor$ 。

因此只考虑 $a=\left \lfloor \frac{r+1}{2} \right \rfloor$ 的情况，不难发现，当 $r$ 为奇数时， $\left \lfloor \frac{r+1}{2} \right \rfloor=\left \lfloor \frac{r+2}{2} \right \rfloor$ ，不成立，因此 $r$ 为偶数，此时 $a=\frac{r}{2}$ ， $r\mod a≡0$ ，不成立。

时间复杂度： $O (1)$

#include<cstdio>
#include<cstring>
using  namespace  std;
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		int  l,r;scanf("%d%d",&l,&r);
		int  mid=r+1;
		if(l>=(mid/2+(mid&1)))printf("YES\n");
		else  printf("NO\n");
	}
	return  0;
}

B

题意：给你一串 $01$ 字符串，长度为 $n$ ， $n$ 为 $偶数$ ，其中一半为 $0$ ，一半为 $1$ ，然后每次操作可以选择 $[l, r]$ 翻转，问最少几次操作可以变成 $s_i≠s_{i+1}$ 的01串，即： $01010101 . . .$ 或者 $10101010101 . . .$

题解：只有两个标准字符串，不妨考虑先转化成 $01010101 . . .$ ，我们称这个为标准字符串，记为 $B$ ，原字符串为 $A$ ，建立新的字符串： $C$ ， $C_{i}=[B_{i}≠A_{i}]$ 。

不难发现，对于 $C$ 中的字符串，选择 $[l, r]$ 进行翻转， $r - l + 1$ 为偶数时，翻转完之后还要对此区间取反，而奇数时便是单纯的翻转。

把一段连续的 $1$ 成为联通块。

分几种情况讨论不难证明每次翻转最多消除一个联通块，所以答案 $\geq$ 联通块数量。

那么现在构造一种方案等于联通块数量。

如果一个联通块的，长度为偶数，直接翻转，这样这会剩下偶数个奇数长度的联通块。

然后对于相邻的两个联通块，如果中间 $0$ 的个数为偶数个，则将一个联通块和中间的 $0$ 翻转，使两个联通块合并成偶数联通块并且一次消除掉。

但是如果相邻的联通块中间都是奇数个 $0$ 呢？其实通过构造 $C$ 的方法以及 $0, 1$ 个数相同，我们不难得到一个结论，奇数位的 $1$ 等于偶数位的 $1$ ，因此不存在相邻联通块中间都是奇数个 $1$ 的情况。

证毕。

然后只要两个标准字符串都搞一遍就可以了。

时间复杂度： $O (n)$

~~因为他们做完后都在说做法，搞得我总感觉不是我自己独立做出来的~~

#include<cstdio>
#include<cstring>
#define  N  110000
using  namespace  std;
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
inline  int  mymax(int  x,int  y){return  x>y?x:y;}
int  a[N],b[N],n;
char  st[N];
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		scanf("%s",st+1);
		for(int  i=1;i<=n;i++)a[i]=st[i]-'0';
		int  ans,sum=0;
		for(int  i=1;i<=n;i++)b[i]=((a[i]&1)==(i&1));
		for(int  i=1;i<=n;i++)
		{
			if(b[i]==1  &&  b[i-1]==0)sum++;
		}
		ans=sum;
		for(int  i=1;i<=n;i++)b[i]=((a[i]&1)!=(i&1));
		sum=0;
		for(int  i=1;i<=n;i++)
		{
			if(b[i]==1  &&  b[i-1]==0)sum++;
		}
		ans=mymin(sum,ans);
		printf("%d\n",ans);
	}
	return  0;
}

C

给你一个数组 $a$ ，满足 $1 \leq a [i] \leq n$ ，然后你需要构造一个正整数数组 $b$ ，其中每个数字都不相同，然后使得 $\sum\limits_{i=1}^n|b[i]-a[i]|$ 最小，问这个值最小是多少。

做法：把 $a$ 排序，不难发现， $b_{n}≤2n$ （事实上，同机房大佬说 $\frac{3n}{2}$ 就够了，想想也是）， $b_{i}<b_{i+1}$ 。

然后跑个 $n^3$ 的DP即可，事实上，可以优化到 $O(n^2)$ 。

时间复杂度： $O(n^3)$

#include<cstdio>
#include<cstring>
#include<algorithm>
#define  N  410
using  namespace  std;
int  dp[N][N],n,a[N];
inline  int  zabs(int  x){return  x<0?-x:x;}
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
inline  bool  cmp(int  x,int  y){return  x<y;}
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
		sort(a+1,a+n+1,cmp);
		int  limit=2*n;
		for(int  i=1;i<=limit;i++)dp[1][i]=zabs(a[1]-i);
		for(int  i=2;i<=n;i++)
		{
			for(int  j=1;j<=limit;j++)
			{
				dp[i][j]=999999999;
				for(int  k=j-1;k>=1;k--)dp[i][j]=mymin(dp[i-1][k]+zabs(a[i]-j),dp[i][j]);
			}
		}
		int  ans=999999999;
		for(int  i=1;i<=limit;i++)ans=mymin(ans,dp[n][i]);
		printf("%d\n",ans);
	}
	return  0;
}

D

题意：给你一个BFS遍历顺序，要求你按照这个顺序找到满足要求的树中高度最小的，输出最小高度，满足对于一个点，会直接将其儿子全部加入到队列中（也就是在BFS顺序中是连续一段的），且儿子被丢进去的顺序是按照儿子的编号从小到大丢的，根固定为 $1$ ，高度为 $0$ 。

做法：我们将顺序中每个递增的连续一小段称为联通块。

不难发现，每个儿子接一个联通块是最优秀的（不难发现，如果只接一般的联通块，一定不会比这种方法优秀），所以下一层的点数一定大于等于这一层的点数。

所以贪心做一下就行了。

#include<cstdio>
#include<cstring>
#define  N  210000
using  namespace  std;
int  n,a[N];
int  main()
{
	int  T;scanf("%d",&T);
	while(T--)
	{
		scanf("%d",&n);
		for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
		int  now=1,used=0,tot=0,h=0,pre=0;
		for(int  i=2;i<=n;i++)
		{
			if(a[i]>pre)pre=a[i],tot++;
			else
			{
				used++;pre=a[i];
				if(used==now)
				{
					h++;used=0;
					now=tot;tot=1;
				}
				else  tot++;
			}
		}
		if(n>1)h++;
		printf("%d\n",h);
	}
	return  0;
}

E

题意：给你 $a, b$ 数组，规定一个操作： $x, i$ 为 $a [x] = i$ 且 $x$ 不在 $b$ 数组中， $b$ 数组严格递增且范围在 $[1, n]$ 中，长度为 $k$ ， $a$ 数组长度为 $n$ 。

然后问你能不能通过最少的操作数把 $a$ 数组变成严格递增，不能输出 $- 1$ ，能输出最小操作数。

做法：额，首先根据 $b$ 数组分成 $k + 1$ 块，经CLB提示，为了代码方便，会在数组两端加入哨兵点，顺利的把 $a$ 数组禁锢在 $b$ 数组中（就是 $b [0] = 0, b [k + 1] = n + 1$ ，同时 $a$ 数组做出类似的变化）。

如果 $a_{b_{i}}-a_{b_{i-1}}-1<b_{i}-b_{i-1}-1$ 就输出 $- 1$ 。

然后考虑对于每一段跑 $D P$ 求出最小的操作数变成递增的， $d p [i]$ 为 $i$ 不改变时前面变成递增的最小操作数。

$d p [i] = m i n (d p [j] + i - j - 1) (a [i] - a [j] - 1 \geq j - i - 1)$

化简一下条件： $a [i] - j \geq a [i] - i$ 。

然后化简一下转移： $d p [i] - i = m i n (d p [j] - j - 1)$ 。

然后这个用线段树维护一下就行了，顺便注意一下细节。（当然，同机房大佬也有用树状数组的，还有师兄用类似的方法直接求了最长上升子序列，应该也是同样的原理）

时间复杂度： $O (n l o g n)$

#include<cstdio>
#include<cstring>
#include<algorithm>
#define  N  510000
#define  SN  11000000
using  namespace  std;
inline  int  mymin(int  x,int  y){return  x<y?x:y;}
struct  node
{
	int  l,r,c;
}tr[SN];int  len,rt;
inline  int  addnode(){len++;tr[len].l=tr[len].r=tr[len].c=0;return  len;}
inline  void  updata(int  x){tr[x].c=mymin(tr[tr[x].l].c,tr[tr[x].r].c);}
inline  void  link(int  &x,int  l,int  r,int  k,int  c)
{
	if(!x)x=addnode();
	if(l==r){tr[x].c=c;return  ;}
	int  mid=(l+r)>>1;
	if(k<=mid)link(tr[x].l,l,mid,k,c);
	else  link(tr[x].r,mid+1,r,k,c);
	updata(x);
}
inline  int  findans(int  x,int  l,int  r,int  c/*小于等于k的*/)
{
	if(r<=c)return  tr[x].c;
	if(!x)return  0;
	int  mid=(l+r)>>1;
	if(mid>=c)return  findans(tr[x].l,l,mid,c);
	else  return  mymin(findans(tr[x].l,l,mid,c),findans(tr[x].r,mid+1,r,c));
}
int  a[N],b[N];
int  id[N],cnt/*离散化*/,be[N],dp[N];
int  n,k;
inline  bool  cmp(int  x,int  y){return  a[x]<a[y];}
int  main()
{
	scanf("%d%d",&n,&k);
	for(int  i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		a[i]-=i;
		id[i]=i;
	}
	sort(id+1,id+n+1,cmp);
	for(int  i=1;i<=n;i++)
	{
		if(a[id[i]]!=be[cnt])cnt++,be[cnt]=a[id[i]];
		a[id[i]]=cnt;
	}
	for(int  i=1;i<=k;i++)scanf("%d",&b[i]);
	for(int  i=2;i<=k;i++)
	{
		if(a[b[i]]<a[b[i-1]])
		{
			printf("-1\n");
			return  0;
		}
	}
	//b[0]=0,a[0]=0;
	cnt++;b[++k]=n+1;a[n+1]=cnt;//哨兵节点 
	int  ans=0;
	for(int  i=1;i<=k;i++)
	{
		len=rt=0;//清除掉整棵树 
		int  l=b[i-1]+1,r=b[i],limit=a[l-1]/*大于这个数字才有资格成为不减的象征*/;
		link(rt,0,cnt,limit,-b[i-1]-1/*十分的有诱惑性*/);
		for(int  j=l;j<=r;j++)
		{
			if(a[j]>=limit)
			{
				dp[j]=findans(rt,0,cnt,a[j])+j;
				link(rt,0,cnt,a[j],dp[j]-j-1);
			}
		}
		ans+=dp[r];
	}
	printf("%d\n",ans);
	return  0;
}

F

题意：现在有 $n$ 个数字的数组 $a$ ，要求你求满足要求的排列 $b$ 的数量。

要求：对于 $b [i]$ 而言，设 $y = m a x (a [b [j]]) (j < i)$ ，那么要求 $a [b [i]] \geq 2 y$ 或者 $2 a [b [i]] \leq y$

做法：~~艹，看错题了，不然超级弱智，也就G不会了~~

先把 $a$ 排序一下。

设 $f [i] [j]$ 为最大值为 $a [i]$ ，填了 $j$ 个数字的方案数，然后暴力转移。

#include<cstdio>
#include<cstring>
#include<algorithm>
#define  N  5100
using  namespace  std;
typedef  long  long  LL;
LL  dp[N][N],f[N],mod=998244353;
int  n,a[N],id[N];
int  main()
{
	scanf("%d",&n);
	for(int  i=1;i<=n;i++)scanf("%d",&a[i]);
	sort(a+1,a+n+1);
	int  l=0;
	for(int  i=1;i<=n;i++)
	{
		while(a[l+1]<=a[i]/2)l++;
		id[i]=l;
		f[i]=1;
	}
	f[0]=1;
	for(int  i=1;i<=n;i++)//一层一层往上DP 
	{
		for(int  j=1;j<=n;j++)
		{
			if(id[j]+1<i)dp[i][j]=0;
			else  dp[i][j]=(f[id[j]]+dp[i-1][j]*(id[j]-i+2))%mod;
		}
		f[0]=0;for(int  j=1;j<=n;j++)f[j]=(f[j-1]+dp[i][j])%mod;
	}
	printf("%lld\n",dp[n][n]);
	return  0;
}