【洛谷5794】[THUSC2015] 解密运算(模拟)

点此看题面

大致题意: 对于一个字符串,我们在其末尾添加一个'.',将字符串视作一个环,则可以从\(n+1\)个位置断开得到\(n+1\)个新串。现将这\(n+1\)个新串按字典序排序('.'的字典序最小),按序给出排序后每个串末位字符,求原字符串。

前言

在一家咖啡店看到这题,在纸上乱涂乱画半天,最后口胡了出来。

不过当时做法比较复杂,后来吃饭时想了想给它整理了一下,最后写出来的做法就很简洁了。

手玩

首先我们来手玩一下样例,或许能从中发现什么。

样例给出的末位字符串是"AAAC.AB"。

通过这个末尾字符串,其实题目还间接给了我们一个信息,即这个字符串显然是由".AAAABC"这七个字符构成的。

而由于它是按字典序排列的,显然首位字符就应该按次是".AAAABC"。

把它写成一个方阵形式,就是:

\[\left\{\begin{matrix}.&?&?&?&?&?&A\\A&?&?&?&?&?&A\\A&?&?&?&?&?&A\\A&?&?&?&?&?&C\\A&?&?&?&?&?&.\\B&?&?&?&?&?&A\\C&?&?&?&?&?&B\end{matrix}\right\} \]

由于字符串成环,也就是说,在上面的每一个字符串中,首位字符在原字符串里都跟在末位字符后面。

也就是说,'.'后面是'A','A'后面是'.'或'A'或'A'或'B','B'后面是'C','C'后面是'A'。

再次因为这些字符串是按字典序排列的,所以我们可以把每种字符后面能够跟着的那些字符排个序,然后再依次填入方阵中。

于是就得到了:

\[\left\{\begin{matrix}.&A&?&?&?&?&A\\A&.&?&?&?&?&A\\A&A&?&?&?&?&A\\A&A&?&?&?&?&C\\A&B&?&?&?&?&.\\B&C&?&?&?&?&A\\C&A&?&?&?&?&B\end{matrix}\right\} \]

上面的做法似乎给了我们点启发,于是我们就可以套路地想到:

"A."后面跟着的是'A',"AA"后面跟着的是'.'或'A',"CA"后面跟着的是'A',".A"后面跟着的是'B',"AB"后面跟着的是'C',"BC"后面跟着的是'A'。

填入方格中,就得到:

\[\left\{\begin{matrix}.&A&B&?&?&?&A\\A&.&A&?&?&?&A\\A&A&.&?&?&?&A\\A&A&A&?&?&?&C\\A&B&C&?&?&?&.\\B&C&A&?&?&?&A\\C&A&A&?&?&?&B\end{matrix}\right\} \]

按照这样的套路,我们就可以轻松把这个矩阵填完整了,剩下的请读者自己去尝试。

而如果把这个算法用程序实现,就是\(O(n^2)\)的复杂度,已经能够得到\(60\)分的好成绩了。

优化

接下来,我们该怎么优化呢?

如果你认认真真把样例给手玩完了,你或许可以发现一个规律:对于每一个串,它总是从同一个串转移过来的。

例如上面的第一个串,它的下一个字符总是从上面的第五个串得到的。

这让我们想到,如果能够直接求出每个串的字符从哪个串转移过来,这道题似乎就做完了。

而这其实是很好求的。

具体地,首先我们把题目中给出的末位字符排序,就得到首位字符串。

然后我们把每个字符串以末位字符为第一关键字、首位字符为第二关键字、编号为第三关键字再次排序,排序完后的第\(i\)个字符串的编号所对应的原先的字符串,就是向它转移的字符串。

如果把转移看作一条边,我们只要从第一个字符串出发,沿反向边遍历一遍,每次取原先字符串(即题目中按字典序排序的字符串)的首位字符(不难发现,原先字符串的首位字符是以首位字符为关键字排序后的结果),就是答案。

至于为什么这么做,有点难以描述,实在不清楚就自己去画画图吧,应该还是比较显然、好理解的。

代码

#include<bits/stdc++.h>
#define Tp template<typename Ty>
#define Ts template<typename Ty,typename... Ar>
#define Reg register
#define RI Reg int
#define Con const
#define CI Con int&
#define I inline
#define W while
#define N 200000
using namespace std;
int n,m,a[N+5];struct data
{
	int H,T,p;I data(CI x=0,CI y=0,CI t=0):H(x),T(y),p(t){}
	I bool operator < (Con data& o) Con {return T^o.T?T<o.T:(H^o.H?H<o.H:p<o.p);}
}s[N+5];
class FastIO
{
	private:
		#define FS 100000
		#define tc() (A==B&&(B=(A=FI)+fread(FI,1,FS,stdin),A==B)?EOF:*A++)
		#define pc(c) (C==E&&(clear(),0),*C++=c)
		#define tn (x<<3)+(x<<1)
		#define D isdigit(c=tc())
		int T;char c,*A,*B,*C,*E,FI[FS],FO[FS],S[FS];
	public:
		I FastIO() {A=B=FI,C=FO,E=FO+FS;}
		Tp I void read(Ty& x) {x=0;W(!D);W(x=tn+(c&15),D);}
		Tp I void write(Ty x) {W(S[++T]=x%10+48,x/=10);W(T) pc(S[T--]);}
		Tp I void write(Con Ty& x,Con char& y) {write(x),pc(y);}
		I void clear() {fwrite(FO,1,C-FO,stdout),C=FO;}
}F;
int main()
{
	RI i;for(F.read(n),F.read(m),i=1;i<=n+1;++i) F.read(a[i]),s[i].T=a[i],s[i].p=i;//读入
	for(sort(a+1,a+n+2),i=1;i<=n+1;++i) s[i].H=a[i];sort(s+1,s+n+2);//排序求出首位字符,然后再次排序
	i=s[1].p;W(i^1) F.write(a[i],' '),i=s[i].p;return F.clear(),0;//遍历,输出首位字符,注意第一个'.'无需输出
}
posted @ 2019-12-21 20:50  TheLostWeak  阅读(...)  评论(...编辑  收藏