Codeforces Round #848 (Div. 2)（持续更新）

1|0Preface

这场打的可以说发挥了水平但没有完全发挥的说

ABC都是一眼一遍过，结果D是我最怕的期望题，大概推了个DP的式子但感觉成环了初始条件又不够（flag）就弃了

本来当时看E只有十几个人过的，抱着随便看看的心态看了眼题面发现是个套路题

结果30minRush完代码后一直连着T了好多发，直到比赛结束前两分钟才卡常卡过去

嘛不过不管怎么说应该不会掉分的说（最近两场的分怎么被CF给吃掉了，还没更新上去就难绷）

2|0A. Flip Flop Sum

SB题，直接按题意枚举即可

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
int t,n,a[N],pfx[N],suf[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) scanf("%d",&a[i]);
		for (pfx[0]=0,i=1;i<=n;++i) pfx[i]=pfx[i-1]+a[i];
		for (suf[n+1]=0,i=n;i>=1;--i) suf[i]=suf[i+1]+a[i];
		int ans=-1e9; for (i=1;i<n;++i) ans=max(ans,pfx[i-1]+suf[i+2]-a[i]-a[i+1]);
		printf("%d\n",ans);
	}
	return 0;
}

3|0B. The Forbidden Permutation

SB题，话说这题题面写的很难懂赛后被好多人喷来着

不难发现由于只要有一个位置不合法即可，我们先特判掉答案为 $0$ 的情况

然后考虑直接枚举每个位置，分别考虑破坏不等式两边所需要的最小步数即可

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005,INF=1e9;
int t,n,m,d,p[N],pos[N],a[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%d",&n,&m,&d),i=1;i<=n;++i)
		scanf("%d",&p[i]),pos[p[i]]=i;
		for (i=1;i<=m;++i) scanf("%d",&a[i]);
		bool flag=0; int ans=INF; for (i=1;i<m;++i)
		{
			int x=pos[a[i]],y=pos[a[i+1]];
			if (y<x||y>x+d) { flag=1; break; }
			ans=min(ans,y-x); if (n-1>d) ans=min(ans,d+1-(y-x));			
		}
		if (flag) puts("0"); else printf("%d\n",ans);
	}
	return 0;
}

4|0C. Flexible String

爆搜题

不难发现关于答案的计算方式，我们只要考虑找出每段连续的两个串对应位置相同的区间长度即可

然后注意到题目中反复提到的字符集大小小于等于 $10$ 的限制，可以直接爆搜改了哪些字符然后check即可

复杂度 $O(2^{10}\times n)$ ，实际情况前面是 $C_{10}^k$ 只会更小

#include<cstdio>
#include<iostream>
#include<vector>
#define RI register int
#define CI const int&
using namespace std;
const int N=100005;
int t,n,k,tot,rst[26]; char a[N],b[N]; bool vis[N],cs[15]; 
vector <int> pos[15]; long long ans;
inline long long C2(CI x)
{
	return 1LL*x*(x+1)/2LL;
}
inline void DFS(CI now=1,CI num=0)
{
	if (num>k) return; if (now==tot+1)
	{
		RI i; for (i=1;i<=n;++i) vis[i]=a[i]==b[i];
		for (i=1;i<=tot;++i) if (cs[i])
		for (int x:pos[i]) vis[x]=1;
		long long ret=0; int lst=0;
		for (i=1;i<=n;++i) if (!vis[i]) ret+=C2(i-1-lst),lst=i;
		ret+=C2(n-lst); ans=max(ans,ret); return;
	}
	cs[now]=1; DFS(now+1,num+1); cs[now]=0; DFS(now+1,num);
}
int main()	
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i; for (tot=0,i=0;i<26;++i) rst[i]=0;
		for (i=0;i<15;++i) pos[i].clear();
		for (scanf("%d%d%s%s",&n,&k,a+1,b+1),i=1;i<=n;++i)
		{
			if (!rst[a[i]-'a']) rst[a[i]-'a']=++tot;
			pos[rst[a[i]-'a']].push_back(i);
		}
		ans=0; DFS(); printf("%lld\n",ans);
	}
	return 0;
}

5|0D. Flexible String Revisit

DP题，方程很好写但是求解需要技巧

不难发现我们只关心两个串不同的位置的个数时多少，因此直接设 $f_{i}$ 表示有 $i$ 个不同位置的期望步数

转移方程显然有： $f_i=f_{i+1}\times\frac{n-i}{n}+f_{i-1}\times \frac{i}{n}+1$

即我们对当前状态进行操作，有 $\frac{i}{n}$ 的概率选中一个不同的位，这样还要操作 $f_{i-1}$ 次，反之则有 $\frac{n-i}{n}$ 的概率还要操作 $f_{i+1}$ 次

然后这个DP看似是成环的，当时我只发现了 $f_0=0$ 这一个终止条件，但没有注意到 $f_n=f_{n-1}+1$ 这个特殊情况

有了这个边界之后我们就可以考虑解方程了，因为那个转移的式子可以写成：

f_{i - 1} = f_{i} \times \frac{n - i + 1}{n} + f_{i - 2} \times \frac{i - 1}{n} + 1 \Leftrightarrow f_{i} = (f_{i - 1} - 1 - f_{i - 2} \times \frac{i - 1}{n}) \times \frac{n}{n - i + 1}

$f_{i-1}=f_{i}\times\frac{n-i+1}{n}+f_{i-2}\times \frac{i-1}{n}+1\\ \Leftrightarrow f_i=(f_{i-1}-1-f_{i-2}\times \frac{i-1}{n})\times \frac{n}{n-i+1}$

这是一个关于前两项的递推式，而根据我们的两个已知条件式可以解出来的

我们不妨设 $f_1$ 是已知的初始条件，最后我们可以把每个 $f_i$ 都用一个二元组 $(x,y)$ 来表示，其中 $f_i=x\times f_1+y$

这样我们在得到了 $f_n,f_{n-1}$ 的表示后可以反解出 $f_1$ 的值，从而推出其中的任意一项了

不得不说这个trick之前没有见过，算是长见识了的说

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=1000005,mod=998244353;
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 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;
}
struct Data // x*f[1]+y
{
	int x,y;
	inline Data(CI X=0,CI Y=0)
	{
		x=X; y=Y;
	}
	friend inline Data operator + (const Data& A,const Data& B)
	{
		return Data(sum(A.x,B.x),sum(A.y,B.y));
	}
	friend inline Data operator - (const Data& A,const Data& B)
	{
		return Data(sub(A.x,B.x),sub(A.y,B.y));
	}
	friend inline Data operator * (const Data& A,const Data& B)
	{
		return Data(1LL*A.x*B.x%mod,1LL*A.y*B.y%mod);
	}
}f[N]; int t,n,invn,dif; char a[N],b[N];
int main()	
{
	//freopen("CODE.in","r",stdin); freopen("CODE.out","w",stdout);
	for (scanf("%d",&t);t;--t)
	{
		RI i; for (scanf("%d%s%s",&n,a+1,b+1),dif=0,i=1;i<=n;++i) dif+=a[i]!=b[i];
		for (f[0]=Data(0,0),f[1]=Data(1,0),invn=quick_pow(n),i=2;i<=n;++i)
		{
			int tmp=1LL*(i-1)*invn%mod,div=quick_pow(sub(1,tmp));
			f[i]=(f[i-1]-Data(0,1)-(f[i-2]*Data(tmp,tmp)))*Data(div,div);
		}
		Data tmp=f[n]-f[n-1]; int f1=1LL*sub(1,tmp.y)*quick_pow(tmp.x)%mod;
		printf("%d\n",sum(1LL*f[dif].x*f1%mod,f[dif].y));
	}
	return 0;
}

6|0E. The Tree Has Fallen!

套路题

一堆数里选一些出来求最大的异或和，这个一眼线性基没跑了

换根操作的话一眼先定根然后再分类讨论，顺着这个思路这题就很简单了

首先假定 $1$ 为根，然后我们考虑在这个有根树上把根换成 $r$ 对于 $v$ 的影响：

当 $r$ 不在 $v$ 的子树中时，不难发现此时我们要找答案的数集就还是 $v$ 的子树
当 $r$ 在 $v$ 的子树中时，手玩一下我们发现，设 $w$ 为 $v$ 的直接儿子，并且满足 $r$ 在 $w$ 的子树中，则此时我们要找答案的数集就是所有数的集合减去 $w$ 的子树

因此我们把数的DFS序求出来，这样就变成了区间询问的题目了，由于线性基支持合并，因此直接上线段树即可

但是由于 $O(n\log^2 n)$ 的复杂度且由于我各部分的封装实现，常数巨大，卡了好久的常数才跑过

后来比赛结束后躺在床上转念一想由于只有查询操作，且两个区间合并时有重复不会影响答案（因为重复的部分相当于插入了两次线性基，对答案没有影响），因此可以用ST表来写

不过由于我太懒的说既然卡过了就万事大吉了，就懒得再写了

#include<cstdio>
#include<iostream>
#include<vector>
#include<cstring>
#define RI register int
#define CI const int&
using namespace std;
const int N=200005,P=30;
int t,n,a[N],x,y,q,dep[N],dfn[N],L[N],R[N],tot; vector <int> v[N];
struct LB
{
	int v[P];
	inline LB(void) { memset(v,0,sizeof(v)); }
	inline void clear(void) { memset(v,0,sizeof(v)); }
	inline void insert(int x)
	{
		for (RI i=P-1;~i;--i) if ((x>>i)&1)
		{
			if (!v[i]) return (void)(v[i]=x); x^=v[i];
		}
	}
	inline int query(int x=0)
	{
		for (RI i=P-1;~i;--i) if ((x^v[i])>x) x^=v[i]; return x;
	}
	friend inline LB operator + (const LB& A,const LB& B)
	{
		LB C; RI i; for (i=0;i<P;++i) C.v[i]=A.v[i];
		for (i=0;i<P;++i) if (B.v[i]) C.insert(B.v[i]); return C;
	}
};
class Segment_Tree
{
	private:
		LB tr[N<<2];
		#define TN CI now=1,CI l=1,CI r=n
		#define LS now<<1,l,mid
		#define RS now<<1|1,mid+1,r
		inline void pushup(CI now)
		{
			tr[now]=tr[now<<1]+tr[now<<1|1];
		}
	public:
		inline void build(TN)
		{
			if (l==r) return tr[now].clear(),tr[now].insert(a[dfn[l]]);
			int mid=l+r>>1; build(LS); build(RS); pushup(now);
		}
		inline LB query(CI beg,CI end,TN)
		{
			if (beg>end) return LB(); if (beg<=l&&r<=end) return tr[now]; int mid=l+r>>1;
			if (beg<=mid&&end<=mid) return query(beg,end,LS);
			if (end>mid&&beg>mid) return query(beg,end,RS);
			return query(beg,end,LS)+query(beg,end,RS);
		}
		#undef TN
		#undef LS
		#undef RS
}SEG;
class Tree_Solver
{
	private:
		int anc[N][20];
	public:
		inline void DFS(CI now=1,CI fa=0)
		{
			RI i; for (i=0;i<20;++i) anc[now][i]=0;
			dep[now]=dep[anc[now][0]=fa]+1; dfn[++tot]=now; L[now]=tot;
			for (i=0;i<19;++i) if (anc[now][i]) anc[now][i+1]=anc[anc[now][i]][i]; else break;
			for (int to:v[now]) if (to!=fa) DFS(to,now); R[now]=tot;
		}
		inline void jump(int& x,CI y)
		{
			for (RI i=20;~i;--i) if ((y>>i)&1) x=anc[x][i];
		}
}T;
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) scanf("%d",&a[i]),v[i].clear();
		for (i=1;i<n;++i) scanf("%d%d",&x,&y),v[x].push_back(y),v[y].push_back(x);
		for (tot=0,T.DFS(),SEG.build(),scanf("%d",&q),i=1;i<=q;++i)
		{
			if (scanf("%d%d",&x,&y),x==y) printf("%d\n",SEG.query(1,n).query()); else
			{
				if (L[y]<=L[x]&&L[x]<=R[y])
				{
					T.jump(x,dep[x]-dep[y]-1);
					printf("%d\n",(SEG.query(1,L[x]-1)+SEG.query(R[x]+1,n)).query());
				} else printf("%d\n",SEG.query(L[y],R[y]).query());
			}
		}
	}
	return 0;
}