noip模拟41

A. 你相信引力吗

很明显的单调栈的题，考场上没有想到平移最大值，而是想着复制一倍序列破环成链，然后发现最大值的部分特别难维护，而且耗费时间过长，只好牺牲时间复杂度加了个 $map$ 去重。

首先把一个最大值放到最左边，这样除了最大值都不能跨过左端点走另一半的环进行匹配
然后维护单调不增栈，对于多个连续值维护当前是第几个，往后递推即可
过程中需要特判最大值防止算重

代码实现

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e7+5;
int n,a[maxn],mxpos,sta[maxn],f[maxn],tp;
long long ans;
int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-')f=-1;
		ch=getchar();	
	}
	while(isdigit(ch)){
		x=x*10+ch-48;
		ch=getchar();	
	}
	return x*f;
}
int main(){
	n=read();
	for(int i=1;i<=n;i++){
		a[i+n]=a[i]=read();
		if(a[i]>a[mxpos])mxpos=i;
	}
	for(int i=mxpos;i<mxpos+n;i++){
		while(tp&&a[sta[tp]]<a[i])ans++,tp--;
		if(a[sta[tp]]>a[i])ans++;
		else ans+=f[sta[tp]]+(a[i]!=a[mxpos]);
		sta[++tp]=i;
		f[i]=(a[i]==a[sta[tp-1]])?f[sta[tp-1]]+1:1;
	}
	while(tp>2){
		if(a[sta[tp]]==a[sta[2]])break;
		tp--;
		ans++;	
	}
	cout<<ans;
	return 0;
}

---

B. marshland

考虑网络流：

如果把格子黑白染色，那么一个有危险值的格子流量为 $2$，但是费用流并不能控制其恰好为 $2$，可能会出现流量为 $1$ 但费用算入贡献的情况

那么可以按如下方法染色：

将棋盘染成类似上述三种颜色：

那么一种合法的方案一定由蓝到红再到黄（假定红色是危险的格子）

那么把红色格子拆点放在中间，连一条费用为危险值的边，蓝色作为左边点，原点向其连边，然后连向中间入点；黄色点放右边，从出点向其连边，然后连向汇点

注意这道题要求可行流，比起传统费用流来讲并不是有流就流，而是当前路径费用为正才流

---

C. party?

特产的选择方案比较奇怪，可以用网络流维护

这其实是一个二分图，左部点是 $c$ 个人，每个人相当于拥有 $k$ 的流量，然后每个人向其对应特产连边，特产流量为一
现在要计算满足满流的最大流量
根据 $Hall$ 定理，二分图存在完美匹配当且仅当对于任意的 $k$，左部任意 $k$ 个点在右边的相邻点个数大于等于 $k$
由于 $c$ 很小，直接枚举所有情况即可

对于统计一条路径上特产有哪些，可以开一个 $bitset$，并用树剖维护
为了防止跳链浪费时间，树剖时对于完整的重链记录其所达特产，只在最后一部分线段树上查询

代码实现

#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+5;
const int len=1005;
const int inf=0x3f3f3f3f;
int n,m,id[maxn],fa[maxn],x,dep[maxn],siz[maxn],son[maxn],re[maxn],tp[maxn],tot,num,pos[maxn],q,hd[maxn],cnt,c[maxn];
bitset<len>col[maxn],S[10];
int read(){
	int x=0,f=1;
	char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-')f=-1;
		ch=getchar();
	}
	while(isdigit(ch)){
		x=x*10+ch-48;
		ch=getchar();
	}
	return x*f;
}
struct Edge{
	int nxt,to;
}edge[maxn];
void add(int u,int v){
	edge[++cnt].nxt=hd[u];
	edge[cnt].to=v;
	hd[u]=cnt;
	return ;
}
void dfs(int u){
	siz[u]=1;
	for(int i=hd[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		dep[v]=dep[u]+1;
		dfs(v);
		siz[u]+=siz[v];
		if(siz[v]>siz[son[u]])son[u]=v;
	}
	return ;
}
void dfs1(int u,int top){
	tp[u]=top;
	id[u]=++tot;
	re[tot]=u;
	if(u!=top)col[u]=col[fa[u]];
	col[u].set(c[u]);//(1<<c[u]);
//	cout<<u<<"    "<<col[u]<<endl;
	if(son[u])dfs1(son[u],top);
	for(int i=hd[u];i;i=edge[i].nxt){
		int v=edge[i].to;
		if(v==son[u])continue;
		dfs1(v,v);
	}
	return ;
}
int lca(int x,int y){
	while(tp[x]!=tp[y]){
		if(dep[tp[x]]<dep[tp[y]])swap(x,y);
		x=fa[tp[x]];	
	}
	if(dep[x]<dep[y])swap(x,y);
	return y;
}
struct Seg{
	int l,r;
	bitset<len>sc;
}t[maxn*4];
void update(int p){
	t[p].sc|=t[p<<1].sc|t[p<<1|1].sc;
	return ;
}
void build(int p,int l,int r){
	t[p].l=l;
	t[p].r=r;
	if(l==r){
		t[p].sc.set(c[re[l]]);
//		t[p].sc|=(1<<c[re[l]]);
		return ;
	}
	int mid=l+r>>1;
	build(p<<1,l,mid);
	build(p<<1|1,mid+1,r);
	update(p);
	return ;
}
bitset<len>ask(int p,int l,int r){
	if(t[p].l>=l&&t[p].r<=r){
		return t[p].sc;
	}
	int mid=t[p].l+t[p].r>>1;
	bitset<len>ans;
	if(l<=mid)ans=ask(p<<1,l,r);
	if(r>mid)ans|=ask(p<<1|1,l,r);
	return ans;
}
bitset<len>que(int x,int ed){
	bitset<len>ans;
	while(tp[x]!=tp[ed]){
		ans|=col[x];
		x=fa[tp[x]];
	}
	ans|=ask(1,id[ed],id[x]);
	return ans;
}
int main(){
	n=read();
	m=read();
	q=read();
	for(int i=2;i<=n;i++){
		fa[i]=read();
		add(fa[i],i);
	}
	for(int i=1;i<=n;i++)c[i]=read();
	dfs(1);
	dfs1(1,1);
//	for(int i=1;i<=n;i++)cout<<col[i]<<endl;
	build(1,1,n);
	for(int i=1;i<=q;i++){
		num=read();
		int d;
		for(int j=1;j<=num;j++){
			if(j==1)d=pos[j]=read();
			else d=lca(d,pos[j]=read());
		}
		for(int j=1;j<=num;j++){
			S[j]=que(pos[j],d);
//			cout<<S[j]<<endl;
		}
		tot=inf;
		for(int T=1;T<=(1<<num)-1;T++){
			bitset<len>sum;
			int pnum=0;
			for(int j=1;j<=num;j++){
				if(T&(1<<(j-1))){
					pnum++;
					sum|=S[j];
				}
			}
			int x=sum.count();
			tot=min(tot,x/pnum);
		}
		for(int j=1;j<=num;j++)S[j].reset();
		printf("%d\n",tot*num);
	}
	return 0;
}

---

D. 半夜

首先题意转化为将 $A$ 串复制一倍，没一个子串与 $B$ 串的 $LCS$
暴力 $n^3$
复习一下 $LCS$ 转移方程式为 $f[i][j]=min(f[i-1][j],f[i][j-1],f[i-1][j-1]+1)$

考虑优化：
设 $f_{i,j,k}=LCS(S[i,j],T[1,k])$
很明显有 $f_{i-1,j,k}>f_{i-1,j-1,k}$ 可以推出 $f_{i,j,k}>f_{i,j-1,k}$
同理 $f_{i,j,k}>f_{i,j,k-1}$ 推出 $f_{i-1,j,k}>f_{i-1,j,k-1}$

那么发现 $dp$ 的转移有分解点 $p_{j,k}$ 和 $q_{j,k}$ 表示:

$$f_{i,j,k}=f_{i,j−1,k}+[i≥p_{k,j}]=f_{i,j,k−1}+[i<q_{k,j}]$$

那么推出下图（盗图 $from$ 这篇博客)：

这是 $P<Q$ 且 $S[j]!=T[k]$ 的情况，设 $f_{i-1,j-1,k-1}=F$ 根据递推式推出前两行，取 $max$ 推出第三行，发现 $p_{j,k}=P$，$q_{j,k}=Q$
所有 $S[j]=T[k]$ 的情况和这个相同

这是 $P>Q$ 的情况，同理推出 $p_{j,k}=Q$，$q_{j,k}=P$

这样两个分界点数组可以递推出来，然后实现 $n^2$ 转移

代码实现

#include<bits/stdc++.h>
using namespace std;
const int maxn=4005;
char a[maxn],b[maxn];
int n,p[maxn][maxn],q[maxn][maxn],sum,ans;
int main(){
	cin>>n;
	scanf("%s",a+1);
	scanf("%s",b+1);
	for(int i=1;i<=n;i++)a[i+n]=a[i];
	for(int i=1;i<=n*2;i++)p[i][0]=i+1,q[i][0]=1;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=n*2;j++){
			int P=p[j][i-1],Q=q[j-1][i];
			if(a[j]!=b[i]&&P>Q){
				p[j][i]=P,q[j][i]=Q;
			}
			else p[j][i]=Q,q[j][i]=P;
		}
	}
	for(int i=1;i<=n;i++){
		sum=0;
		for(int j=i;j<n+i;j++){
			if(i>=p[j][n])sum++;
		}
		ans=max(ans,sum);
	}
	cout<<ans;
	return 0;
}