Codeforces Round #842 (Div. 2)

1|0Preface

唉现在这是是做稍微难点的SB题（指Div2正常场的CD难度）总是要犯病

因此Rating上不去不说，比赛的时候连EF题面都没机会看一眼

这场先是C交上去忘记本机调试的时候把数组开小了挂了一发（本地IDE不能看很大的数组，辣鸡Dev）

然后一个D思路不顺畅，交上去WA了一发后思考了好久才发现原来的判断方法的问题，虽然在结束前两分钟改出来了但是分数已经惨不忍睹了

补题的这场的EF还行的说，顺手就都写掉了（唉又回想起以前OI全盛期的时候刷Div2都是倒着往前做的，现在菜成这个狗样）

2|0A. Greatest Convex

因为 $x!+(x-1)!=(x+1)\times (x-1)!$ ，因此直接输出 $k-1$ 即可

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
int t,k;
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t) scanf("%d",&k),printf("%d\n",k-1);
	return 0;
}

3|0B. Quick Sort

先直接上结论，找出以 $1$ 开头的最长的按顺序出现的 $1,2,\cdots,len$ 的长度 $len$ ，则剩下的 $n-len$ 个位置都必须被操作

证明的话很容易，首先所有在 $1$ 之前的数都一定要操作，然后不在这个顺序里的数也必须要被拎出来

至于操作顺序总能找到一个次数最少的，最后答案就是 $\lceil \frac{n-len}{k} \rceil$

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
int t,n,k,a[N],pos[N];
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i; for (scanf("%d%d",&n,&k),i=1;i<=n;++i) scanf("%d",&a[i]),pos[a[i]]=i;
		int len=1; while (len<n&&pos[len]<pos[len+1]) ++len;
		printf("%d\n",(n-len+k-1)/k);
	}
	return 0;
}

4|0C. Elemental Decompress

这种C题一般想到什么思路直接冲一发基本就没问题了，我还傻愣愣地去证做法的正确性，导致写完这题排名已经1000+了

首先判断掉一些显然无解的情况，比如某个数出现了 $3$ 次及以上

然后考虑所有出现了两次的数，显然两个串在这对应的位置上必须要出现这个数，至于两个串里对应位置的分配对答案没有影响

那么剩下的就是只出现了一次的数了，我们不妨把它们全部扔到一个串里去，因为这些数之间肯定是能构成排列的（没有重复）

比如样例的第二个情况，在做完上面的两个操作后得到（用.代表不确定的位置）

5 3 4 2 .
. . . . 5

然后我们考虑怎么填上每个串里各自位置的空缺，以上面的例子填上第二个串的空缺为例

我们把第二个串所有没1出现过的数1 2 3 4，依次按对应的大小顺序填到第一个串对应的数的对应位置上

比如填完后第二个串就变成4 2 3 1 5，然后检查一下是否会出现有位置上的数大于第一个串的即可

对于第一个串的空位也是和上面一样的方法，如法炮制即可

#include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
#define RI register int
#define CI const int&
using namespace std;
const int N=200005;
struct element
{
	int val,id;
	friend inline bool operator < (const element& A,const element& B)
	{
		return  A.val<B.val;
	}
}p[N]; int T,n,cnt,c[N],tp[N],a[N],b[N]; bool va[N],vb[N]; vector <int> t[N];
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&T);T;--T)
	{
		RI i; for (scanf("%d",&n),i=1;i<=n;++i) a[i]=b[i]=va[i]=vb[i]=0,t[i].clear();
		for (i=1;i<=n;++i) scanf("%d",&c[i]),t[c[i]].push_back(i);
		bool flag=1; for (i=1;i<=n&&flag;++i) if (t[i].size()>2) flag=0;
		if (!flag) { puts("NO"); continue; }
		for (i=1;i<=n;++i) if (t[i].size()==2)
		a[t[i][0]]=i,b[t[i][1]]=i;
		else if (t[i].size()==1) a[t[i][0]]=i;
		for (i=1;i<=n;++i) va[a[i]]=vb[b[i]]=1,tp[i]=a[i];
		for (cnt=0,i=1;i<=n;++i) if (b[i]) p[++cnt]=(element){b[i],i};
		int lst=1; for (sort(p+1,p+cnt+1),i=1;i<=cnt&&flag;++i)
		{
			while (va[lst]) ++lst; if (lst>p[i].val) flag=0;
			else va[lst]=1,a[p[i].id]=lst;
		}
		for (cnt=0,i=1;i<=n;++i) if (tp[i]) p[++cnt]=(element){tp[i],i};
		lst=1; for (sort(p+1,p+cnt+1),i=1;i<=cnt&&flag;++i)
		{
			while (vb[lst]) ++lst; if (lst>p[i].val) flag=0;
			else vb[lst]=1,b[p[i].id]=lst;
		}
		if (!flag) { puts("NO"); continue; }
		for (puts("YES"),i=1;i<=n;++i)
		printf("%d%c",a[i]," \n"[i==n]);
		for (i=1;i<=n;++i)
		printf("%d%c",b[i]," \n"[i==n]);
	}
	return 0;
}

5|0D. Lucky Permutation

首先考虑如果不是恰好一个逆序对这个限制，而是把整个序列复原有序，操作步数是多少

说到交换以及排列，很容易想到用置换环，具体地，我们把每个位置 $i$ 和其上的值 $p_i$ 连边，这样就可以得到若干个联通块，其中每个联通块一定是一个简单环

我们很容易发现，对于每一个简单环，需要用 $size-1$ 次操作来复原环上的所有元素（每一次交换操作恢复一个位置，最后一次操作恢复两个）

有了这个结论之后我们考虑恰好一个逆序对的条件，不难发现恰有一个逆序对的排列就是把 $1,2,\cdots,n$ 的排列的某两个相邻的数交换下得到的

那么我们枚举 $i,i+1$ ，考虑交换它们两个之后带来的影响，不难发现其实就是断开原来图中 $(i,a_i),(i+1,a_{i+1})$ 的边，改连成 $(i,a_{i+1}),(i+1,a_i)$

首先我们发现如果 $i,i+1$ 在原来的图中不再一个环内，那么这般操作后这两个环会合并，这样答案就是原来的答案 $+1$

如果 $i,i+1$ 在一个环内，就要视情况讨论，如果可以使得它们所在的环分成两个小的，那么答案就是原来的答案 $-1$

考虑怎么判断这种情况，我的做法是把环上的点都找出来，按顺序排成一个序列

然后找到其中要删除的两条边，这两条边把原来的环分成了两个部分

考虑新加入的边是在这两部分内部连边还是在两部分之间连边即可，具体的实现当时脑子不清实现的可能有些复杂，不过大意是这样的没问题的说

#include<cstdio>
#include<iostream>
#include<vector>
#define RI register int
#define CI const int&
using namespace std;
const int N=200005;
int t,n,a[N],fa[N],sz[N],ans,ret,vis[N],num[N]; vector <int> v[N],pt[N];
inline int getfa(CI x)
{
	return fa[x]!=x?fa[x]=getfa(fa[x]):x;
}
inline void addedge(CI x,CI y)
{
	v[x].push_back(y); v[y].push_back(x);
}
inline void DFS(vector <int>& p,CI now,CI ct=1)
{
	p.push_back(now); vis[now]=1; num[now]=ct;
	for (int to:v[now]) if (!vis[to]) DFS(p,to,ct+1);
}
int main()
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i; for (scanf("%d",&n),i=1;i<=n;++i) sz[i]=vis[i]=num[i]=0,fa[i]=i,v[i].clear();
		for (i=1;i<=n;++i) scanf("%d",&a[i]),fa[getfa(i)]=getfa(a[i]),addedge(i,a[i]);
		for (i=1;i<=n;++i) ++sz[fa[i]=getfa(i)];
		for (ans=1e9,ret=0,i=1;i<=n;++i) if (fa[i]==i) ret+=sz[i]-1,DFS(pt[i],i);
		for (i=1;i<n;++i)
		{
			int cur=ret; if (fa[i]==fa[i+1])
			{
				if (sz[fa[i]]==2) --cur; else
				{
					int S=sz[fa[i]],A=num[i],B=num[a[i]];
					if (A==S&&B!=S-1) B=S+1; if (B==S&&A!=S-1) A=S+1; if (A>B) swap(A,B);
					int C=num[i+1],D=num[a[i+1]];
					if (C==S&&D!=S-1) D=S+1; if (D==S&&C!=S-1) C=S+1; if (C>D) swap(C,D);
					if (A>C) swap(A,C),swap(B,D);
					if (B<=num[i]&&num[i]<=C&&B<=num[a[i+1]]&&num[a[i+1]]<=C) --cur; else
					if (B<=num[i+1]&&num[i+1]<=C&&B<=num[a[i]]&&num[a[i]]<=C) --cur; 
				}
			} else cur=ret+1;
			ans=min(ans,cur);
		}
		printf("%d\n",ans);
	}
	return 0;
}

6|0E. Partial Sorting

知道思路就豁然开朗的数数题，感觉比赛的时候不写D开E可能会更好点

首先我们发现答案的上界为 $3$ ，因为不管是怎样的排列，我们都可以通过依次进行操作 $1$ ，操作 $2$ ，操作 $1$ 来使得它有序

证明也很简单，第一次执行操作 $1$ 后所有大于 $2n$ 的元素一定在 $[n+1,3n]$ 上了，这样在第二次执行操作 $2$ 后所有大于 $2n$ 的数都会归位，然后再执行一次操作 $3$ 就都有序了

那么我们只要考虑统计出操作次数为 $0,1,2,3$ 的排列的个数即可统计答案了

首先是操作次数为 $0$ 的排列，其个数 $t0=1$ 是显然的

然后是操作次数为 $1$ 的排列，记其个数为 $t1$ ，我们可以用容斥的思想，先分别考虑以下两种情况：

前 $n$ 个元素已经排列好了，只用考虑后面的 $2n$ 个元素
后 $n$ 个元素已经排列好了，只用考虑前面的 $2n$ 个元素

但这样得到的部分会有重复，因此要减去前 $n$ 个元素已经排列好且后 $n$ 个元素已经排列好的排列数目

而且这样得到的个数是操作次数小于等于 $1$ 的排列个数，因此要减去 $t0$

接下来考虑操作次数为 $2$ 的排列个数 $t2$ ，还是和上面类似，我们直接先考虑操作次数小于 $2$ 的：

所有小于等于 $n$ 的元素已经在 $[1,2n]$ 中了，此时只要先给前 $2n$ 个元素排序，这样前 $n$ 个数归位后，再给后 $2n$ 个数排序即可
所有大于 $2n$ 的元素已经在 $[2n+1,3n]$ 中了，理由同上

然后类似的我们也要容斥掉同时满是上面两种情况的排列的个数，不妨枚举 $[n+1,2n]$ 内有多少个小于等于 $n$ 的数来计算

当然得到的结果要减去 $t0+t1$ 才是操作次数等于 $2$ 的方案数

最后操作次数等于 $3$ 的方案数就直接 $t3=(3n)!-t0-t1-t2$ 即可，总复杂度 $O(n)$

#include<cstdio>
#define RI register int
#define CI const int&
using namespace std;
const int N=3000005;
int n,mod,fact[N],ifact[N],t0,t1,t2,t3;
inline int quick_pow(int x,int p=mod-2,int mul=1)
{
	for (;p;p>>=1,x=1LL*x*x%mod) if (p&1) mul=1LL*mul*x%mod; return mul;
}
inline int sum(CI x,CI y)
{
	return x+y>=mod?x+y-mod:x+y;
}
inline int sub(CI x,CI y)
{
	return x-y<0?x-y+mod:x-y;
}
inline void init(CI n)
{
	RI i; for (fact[0]=i=1;i<=n;++i) fact[i]=1LL*fact[i-1]*i%mod;
	for (ifact[n]=quick_pow(fact[n]),i=n-1;~i;--i) ifact[i]=1LL*ifact[i+1]*(i+1)%mod;
}
inline int C(CI n,CI m)
{
	return 1LL*fact[n]*ifact[m]%mod*ifact[n-m]%mod;
}
int main()
{
	scanf("%d%d",&n,&mod); init(3*n); t0=1;
	t1=sub(sub(2LL*fact[2*n]%mod,fact[n]),t0);
	t2=2LL*C(2*n,n)*fact[n]%mod*fact[2*n]%mod;
	for (RI i=0;i<=n;++i)
	t2=sub(t2,1LL*C(n,i)*C(n,n-i)%mod*fact[n]%mod*C(2*n-i,n)%mod*fact[n]%mod*fact[n]%mod);
	t2=sub(t2,sum(t0,t1));
	t3=sub(fact[3*n],sum(sum(t0,t1),t2));
	return printf("%d",(1LL*t1+2LL*t2+3LL*t3)%mod),0;
}

7|0F. Wonderful Jump

感觉很像那种经典的决策单调性优化DP的模型，但是之前是区间和乘上距离差的平方，这里改成了区间最小值一时不知所措

看了Tutorial才发现 $a_i\le n$ 的深意所在，妙哉妙哉

考虑设 $f_i$ 表示从 $1$ 跳到 $i$ 的最小代价，考虑 $i$ 从 $j$ 转移来，首先有两个关键结论要注意到：

$\min_\limits{j\le k\le i} a_k$ 等于 $a_i$ 或 $a_j$ ，否则我们可以找到 $(j,i)$ 中最小值的位置 $p$ ，从 $j$ 转移到 $p$ 再从 $p$ 转移到 $i$ 一定可以使得答案更优
当满足 $\min_\limits{j\le k\le i} a_k\times (i-j)^2>n\times (i-j)$ 时，一定不可能从 $j$ 转移到 $i$ ，因为此时一步步转移的代价更小

考虑第二个结论的意义所在，我们化简以下会发现此时 $i-j\le \frac{n}{\min_\limits{j\le k\le i} a_k}$ ，那么我们发现当 $\min_\limits{j\le k\le i} a_k$ 较大的时候 $j$ 的移动范围就很小了

因此很容易想到根号分治，我们考虑根据 $a_i$ 和 $S=\sqrt n$ 的大小情况来讨论：

当 $a_i\ge S$ 时， $i-j\le S$ ，因此可以直接 $O(S)$ 暴力转移
当 $a_i\le S$ 时，分 $a_i$ 为最小值和 $a_j$ 为最小值的情况讨论：
- 若 $a_j$ 为最小值，我们可以直接用单调栈来维护前面的转移点，这样的转移点不会超过 $O(S)$ 个
- 若 $a_i$ 为最小值，我们可以直接暴力往前枚举，一旦遇到 $a_j\le a_i$ 就停下，这样的均摊复杂度是 $O(nS)$ 的

关于均摊复杂度的计算其实也很简单，我们考虑每个位置和每个小于 $S$ 的值，每个位置向同一个值最多转移一次

比如存在 $a_i,a_j,a_k$ ，其中 $a_i<a_j=a_k$ ，那么 $i$ 只会向 $j$ 转移而不会向 $k$ 转移，因此复杂度均摊下来是对的

总复杂度就是 $O(nS)=O(n\sqrt n)$

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=400005,S=650;
int n,a[N],stk[N],top; long long f[N];
int main()
{
	RI i,j; for (scanf("%d",&n),i=1;i<=n;++i) scanf("%d",&a[i]);
	for (stk[top=1]=1,i=2;i<=n;++i)
	{
		int mi=a[i]; for (f[i]=1e18,j=i-1;j>=1&&i-j<=S;--j)
		mi=min(mi,a[j]),f[i]=min(f[i],f[j]+1LL*mi*(i-j)*(i-j));
		for (j=1;j<=top;++j)
		f[i]=min(f[i],f[stk[j]]+1LL*a[stk[j]]*(i-stk[j])*(i-stk[j]));
		if (a[i]<=S)
		{
			for (j=i-1;j>=1;--j)
			if (f[i]=min(f[i],f[j]+1LL*a[i]*(i-j)*(i-j)),a[j]<=a[i]) break;
			while (top&&a[stk[top]]>=a[i]) --top; stk[++top]=i;
		}
	}
	for (i=1;i<=n;++i) printf("%lld ",f[i]);
	return 0;
}

8|0Postscript

小掉了13pts，下场争取加把劲

__EOF__

本文作者：hl666
本文链接：https://www.cnblogs.com/cjjsb/p/17031688.html
关于博主：复活的ACM新生，目前爱好仅剩Gal/HBR/雀魂/单机/OSU
版权声明：转载请注明出处
声援博主：欢迎加QQ：2649020702来DD我

posted @ 2023-01-06 21:51 空気力学の詩阅读(64) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· Codeforces Round 922 (Div. 2)

· Codeforces Round 858 (Div. 2)

· Codeforces Round #842 (Div. 2)

· Codeforces Round #842 (Div. 2) A-D题解

· [个人训练]-Codeforces Round #842 (Div. 2)-A~F

阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列1：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现
· Apache Tomcat RCE漏洞复现（CVE-2025-24813）

公告

Codeforces Round #842 (Div. 2)

发表于 2023-01-06 21:51阅读次数：64评论次数：0

Codeforces 比赛

关注

跳至底部

昵称：空気力学の詩
园龄： 7年5个月
粉丝： 311
关注： 14

+加关注

hl666

空気力学の詩

Codeforces Round #842 (Div. 2)

1|0Preface

2|0A. Greatest Convex

3|0B. Quick Sort

4|0C. Elemental Decompress

5|0D. Lucky Permutation

6|0E. Partial Sorting

7|0F. Wonderful Jump

8|0Postscript

公告

hl666

Codeforces Round #842 (Div. 2)

搜索

常用链接

我的标签

积分与排名

随笔分类

随笔档案

相册

阅读排行榜

评论排行榜

推荐排行榜

最新评论