ZR7.26

7.26

A

并查集维护,时间复杂度我写的貌似不大对,先鸽一鸽

B

敦爷:\(w\)是这个区间的最大值当且仅当他是这个区间内最大的

我们发现结合昨天课件内的并查集

发现我们每次不断合并的本质是把所有\(<=w\)的边连上

我们将这条边连接的两个连通块连到一起时,连个联通块的大小就是贡献

我们把边权按照大小排序

一条条的加进去

那么总的贡献就是\(w*size(a) *size(b)\)

当然,这只是一次合并的总的贡献

这时候我们发现单个元素的贡献是可以顺便维护的

即使对于\(a\)中联通块的元素

每个贡献都有\(w*size(b)\)

\(b\)同理

这只是一条链的情况

我们考虑树上该怎么做

点权转成边权

同理每次考虑合并每个链连通的两个联通块

我们要按秩合并,不要路径压缩

每个并查集的根节点都要维护两个东西

首先是当前子树的\(tag\)

因为上面说的这个连通块内的每个元素都是有贡献的

我们在根节点上打上\(tag\)后面下放一遍记好了

我们想一下

\(a\),\(b\)两个联通块合并我们假设\(a\)的\(size\)比较小一些

那个应该是

\(tag_a += w*size_b\)

\(tag_b+=w*size_a\)

但是我们发现,我们把\(a\)并到\(b\)上之后

原本在\(b\)上的\(tag\)对\(a\)是没有效果的,我们下放的时候却会计算到里面

所以我们要让这一部分的贡献减去

\(tag_a -=tag_b\)

#include<cstdio>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<cctype>
#include<vector>
#define LL long long

using namespace std;
const int N = 4e5 + 311;
int n,m,tot;
LL ans[N];
int fa[N],size[N];
LL w[N];
vector <int> G[N];
struct edge{
	int from;
	int to;
	LL data;	
}e[N << 1];
inline int getf(int x){
	return x == fa[x] ? x : getf(fa[x]);
}
inline bool cmp(edge x,edge y){
	return x.data < y.data;	
}
inline int read(){
	int v = 0,c = 1;char ch = getchar();
	while(!isdigit(ch)){
		if(ch == '-') c = -1;
		ch = getchar();
	}
	while(isdigit(ch)){
		v = v * 10 + ch - 48;
		ch = getchar();
	}
	return v * c;
}
inline void dfs(int x,int f){
	ans[x] += ans[f];
	for(int i = 0;i < (int)G[x].size();++i){
		int y = G[x][i];
		if(y == f) continue;
		dfs(y,x); 
	}	
}
int main(){
	n = read();
	for(int i = 2;i <= n;++i){
		int x = read();
		e[++tot] = (edge){i,x,0};
	}
	for(int i = 1;i <= n;++i) w[i] = read();
	for(int i = 1;i <= n + 13;++i) fa[i] = i,size[i] = 1;
	for(int i = 1;i <= tot;++i) e[i].data = max(w[e[i].from],w[e[i].to]);
//	for(int i = 1;i <= tot;++i){
//		printf("%d %d %lld\n",e[i].from,e[i].to,e[i].data);	
//	}
	sort(e + 1,e + tot + 1,cmp);
	for(int i = 1;i <= tot;++i){
		int x = getf(e[i].from),y = getf(e[i].to);
		if(size[x] > size[y]) swap(x,y);
		if(x == y) continue;
	//	printf("%d %d %lld %lld\n",x,y,ans[x],ans[y]);
		G[y].push_back(x);
		ans[y] += e[i].data * size[x];
		ans[x] += e[i].data * size[y];
		ans[x] -= ans[y];
		size[y] += size[x];
		fa[x] = y;
	}
	dfs(getf(1),0);
	for(int i = 1;i <= n;++i) printf("%lld ",ans[i] + w[i]);
	return 0;	
}

C

问你删除循序的题目

一定要先考虑那个数最后被删掉

我们枚举那个数最后被删掉

如果一个数最后被删掉

那么这个数两边的数永远也不会相邻

我们发现如果我们已经处理出来了

左边的方案数\(A\),右边的方案数\(B\)

那么答案就是\(C_{A + B}^A\)

我们考虑暴力DP

我们设\(f_{l,r,lx,rx}\)表示区间\([l,r]\),且满足左端点不等于\(l_x\),右端点不等于\(r_x\)时的答案

转移我们就枚举区间分裂位置\(k\)

\(f_{l,r,lx,rx} = \sum _{i = l}^rC_{r - l}^{k - l}*f_{l,k - 1,lx,a_{k}} * f_{k + 1,r,a_k,r_x}\)

注意要乘一下组合数

因为这里对与两种不同的合法方案

将他们合并顺序不同可能会影响答案

而合并的总的可能循序就是一共\(r - l\)个位置,有\(k - l\)个位置在操作左边

这样就得到了一个\(n^5\)的做法

之后我们发现这个做法有点蠢

因为对于一个确定\([l,r ]\),\(lx,rx\)一定是确定的

因为你想一下我们DP过程,是钦定一个位置最后选

那么这时候就被卡住了

分裂后的区间的限制

也就是说\([l,r]\)的限制一定是我们强制了\(a_{l -1}\)和\(a_{r + 1}\)得到的

之后发现\(r_x\)和\(l_x\)这一维是固定的,不需要枚举

那么,DP方程就可以简化为

\(f_{l,r} = \sum_{k = l}^rC_{r -l}^{k - 1}*f_{l,k - 1}*_{k + 1,r}\)

\(k\)就是我们要枚举的子区间最后一个删除的位置

很明显转移要有\(a_{k}!=a_{l - 1}\)和\(a_{k}!= a_{r + 1}\)

另外,为了防止\(f_{l,k - 1}\)中\(l > k - 1\)的情况导致漏掉答案

初始化时\(f_{i + 1,i} = 1\)

也是必要的

#include<iostream>
#include<cctype>
#include<queue>
#include<algorithm>
#include<cstring>
#include<vector>
#include<cstdio>
#include<stack>
#define LL long long
const int N = 505;
const LL mod = 998244353;
using namespace std;
LL f[N][N];
LL fac[N],inv[N];
int n;
int a[N];
inline int read(){
	int v = 0,c = 1;char ch = getchar();
	while(!isdigit(ch)){
		if(ch == '-') c = -1;
		ch = getchar();
	}
	while(isdigit(ch)){
		v = v * 10 + ch - 48;
		ch = getchar();
	}
	return v * c;
}
inline LL quick(LL a,LL b){
	LL res = 1;
	while(b){
		if(b & 1) res = res * a % mod;
		b >>= 1;
		a = a * a % mod;	
	}
	return res;
}
inline LL C(int x,int y){
	return fac[x] * inv[y] % mod * inv[x - y] % mod;	
}
inline LL mo(LL x){
	if(x >= mod) x -= mod;
	return x;	
}
int main(){
	scanf("%d",&n);
	fac[0] = inv[0] = fac[1] = inv[1] = 1;
	for(int i = 2;i <= n;++i){
		fac[i] = fac[i - 1] * i % mod;
		inv[i] = quick(fac[i],mod - 2);	
	}
	for(int i = 1;i <= n;++i) a[i] = read();
	for(int i = 1;i < n;++i)
	if(a[i] == a[i + 1]){
		printf("0\n");
		return 0;
	}
			
	for(int i = 1;i <= n;++i) f[i][i] = f[i][i - 1] = 1;
	f[n + 1][n] = 1;
	a[0] = a[n + 1] = -1;
	for(int len = 2;len <= n;++len){
		for(int l = 1;l + len - 1 <= n;++l){
			int r = l + len - 1;
			for(int k = l;k <= r;++k){
				if(a[k] != a[l - 1] && a[k] != a[r + 1])
				f[l][r] = mo(f[l][r] + C(r - l,k - l) * f[l][k - 1] % mod * f[k + 1][r]) % mod; 	
			}
		}
	}
	printf("%lld\n",f[1][n]); 
	return 0;	
}