【ZJOI2019】Minimax（动态DP）（链分治）

于 2019-08-28 11:35:16 发布
阅读量204 收藏
点赞数
分类专栏： 动态DP 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxyoi_dreamer/article/details/100115446
版权

传送门

题解：

当时做ZJOI的时候Day1就这一道不会，只写了70pts暴力（当时连DDP都不知道是什么东西）。

首先和ZJOI2019 D1T1一样的转化思想，并不好计算稳定度为 k k k的集合，考虑计算稳定度不超过 k k k的。

首先我们知道初始状态有一条唯一的答案链。

链上任何一个节点的权值改变都会导致答案改变，并且链上所有点的权值在初始情况下都等于答案。

对于深度奇偶性分类讨论，然后补集转化就能 O ( n ) O(n) O(n)算出不超过 k k k的集合个数。

显然是一个DDP。发现维护其实就是直接一次函数复合后在 0 0 0的点值。

用全局平衡二叉树会很麻烦，需要对删去答案链后的所有连通块建立全局平衡二叉树。

直接链分治+线段树搞定了。

代码（70pts暴力）：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define gc get_char
#define cs const

namespace IO{
	inline char get_char(){
		static cs int Rlen=1<<20|1;
		static char buf[Rlen],*p1,*p2;
		return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,Rlen,stdin),p1==p2)?EOF:*p1++;
	}
	
	inline int getint(){
		re char c;
		while(!isdigit(c=gc()));re int num=c^48;
		while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
		return num;
	}
}
using namespace IO;

using std::cout;
using std::cerr;

inline void ckmax(int &a,int b){a<b?a=b:a;}
inline void ckmin(int &a,int b){a>b?a=b:a;}

cs int mod=998244353;
inline int add(int a,int b){return a+b>=mod?a+b-mod:a+b;}
inline void Inc(int &a,int b){(a+=b)>=mod?a-=mod:a;}
inline int dec(int a,int b){return a<b?a-b+mod:a-b;}
inline int mul(int a,int b){return (ll)a*b%mod;}
inline int quickpow(int a,int b,int res=1){
	while(b){
		res=mul(res,a);
		a=mul(a,a);
		b>>=1;
	}
	return res;
}

cs int N=2e5+5;

int n;
int p2[N];

std::vector<int> G[N];
inline void addedge(int u,int v){
	G[u].push_back(v);
	G[v].push_back(u);
}

int val[N],siz[N],dep[N];

void dfs(int u,int fa){
	if(dep[u]&1)val[u]=1;
	else val[u]=n;
	bool leaf=true;
	for(re int v:G[u])if(v^fa){
		leaf=false;
		dep[v]=dep[u]+1;
		dfs(v,u);
		siz[u]+=siz[v];
		if(dep[u]&1)ckmax(val[u],val[v]);
		else ckmin(val[u],val[v]);
	}
	if(leaf){
		siz[u]=1;
		val[u]=u;
	}
}

int get_max(int u,int fa,int d,int aim){
	if(G[u].size()==1)return (int)(val[u]<=aim)+(int)(val[u]+d<=aim);
	if(dep[u]&1){
		int res=1;
		for(re int v:G[u])if(v!=fa)
		res=mul(res,get_max(v,u,d,aim));
		return res;
	}
	else {
		int res=1;
		for(re int v:G[u])if(v!=fa)
		res=mul(res,dec(p2[siz[v]],get_max(v,u,d,aim)));
		return dec(p2[siz[u]],res);
	}
}

int get_min(int u,int fa,int d,int aim){
	if(G[u].size()==1)return (int)(val[u]>=aim)+(int)(val[u]-d>=aim);
	if(dep[u]&1){
		int res=1;
		for(re int v:G[u])if(v!=fa)
		res=mul(res,dec(p2[siz[v]],get_min(v,u,d,aim)));
		return dec(p2[siz[u]],res);
	}
	else {
		int res=1;
		for(re int v:G[u])if(v!=fa)
		res=mul(res,get_min(v,u,d,aim));
		return res; 
	}
}

int get_ans(int u,int fa,int d){
	int res=1;
	for(re int v:G[u])if(v!=fa){
		if(val[u]==val[v])res=mul(res,get_ans(v,u,d));
		else if(dep[u]&1)res=mul(res,get_max(v,u,d,val[u]));
		else res=mul(res,get_min(v,u,d,val[u]));
	}
	return res;
}

inline int get_ans(int w){
	if(!w)return 0;
	if(w==n)return p2[siz[1]]-1;
	return dec(p2[siz[1]],get_ans(1,0,w));
}

int l,r;
int ans[N];
signed main(){
//	freopen("lx.in","r",stdin);
	n=getint(),l=getint(),r=getint();
	for(int re i=1;i<n;++i)addedge(getint(),getint());
	dep[1]=1;dfs(1,0);
	p2[0]=1;
	for(int re i=1;i<=n;++i)p2[i]=add(p2[i-1],p2[i-1]);
	for(int re i=l-1;i<=r;++i)
	ans[i]=get_ans(i);
	for(int re i=l;i<=r;++i)
	cout<<dec(ans[i],ans[i-1])<<" ";
	return 0;
}

代码（链分治）：

#include<bits/stdc++.h>
#define ll long long
#define re register
#define gc get_char
#define cs const

namespace IO{
	inline char get_char(){
		static cs int Rlen=1<<22|1;
		static char buf[Rlen],*p1,*p2;
		return (p1==p2)&&(p2=(p1=buf)+fread(buf,1,Rlen,stdin),p1==p2)?EOF:*p1++;
	}
	
	template<typename T>
	inline T get(){
		char c;
		while(!isdigit(c=gc()));T num=c^48;
		while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
		return num;
	}
	inline int gi(){return get<int>();}
}
using namespace IO;

using std::cerr;
using std::cout;

cs int mod=998244353;
inline int add(int a,int b){a+=b-mod;return a+(a>>31&mod);}
inline int dec(int a,int b){a-=b;return a+(a>>31&mod);}
inline int mul(int a,int b){ll r=(ll)a*b;return r>=mod?r%mod:r;}
inline int power(int a,int b,int res=1){
	for(;b;b>>=1,a=mul(a,a))(b&1)&&(res=mul(res,a));
	return res;
}
inline void Inc(int &a,int b){a+=b-mod;a+=a>>31&mod;}
inline void Dec(int &a,int b){a-=b;a+=a>>31&mod;}
inline void Mul(int &a,int b){a=mul(a,b);}

struct num{
	int x,y;
	num(){*this=1;}
	void operator=(int v){v?(x=v,y=0):(x=y=1);}
	void operator*=(int v){v?x=mul(x,v):++y;}
	void operator/=(int v){v?x=power(v,mod-2,x):--y;}
	operator int()cs{return y?0:x;}
};

struct func{
	int k,b;
	func(){}
	func(int _k,int _b):k(_k),b(_b){}
	func operator()(cs func &y)cs{
		return func(mul(k,y.k),add(mul(k,y.b),b));
	}
};

cs int N=2e5+5;

namespace SGT{
#define lc k<<1
#define rc k<<1|1
	func f[N<<2];
	
	inline void pushup(int k){
		f[k]=f[lc](f[rc]);
	}
	
	inline void build(int k,int l,int r){
		f[k]=func(1,0);
		if(l==r)return ;
		int mid=l+r>>1;
		build(lc,l,mid);
		build(rc,mid+1,r);
	}
	
	inline void modify(int k,int l,int r,int p,func v){
		if(l==r){f[k]=v;return ;}
		int mid=l+r>>1;
		if(p<=mid)modify(lc,l,mid,p,v);
		else modify(rc,mid+1,r,p,v);
		pushup(k);
	}
	
	inline func query(int k,int l,int r,int ql,int qr){
		if(ql<=l&&r<=qr)return f[k];
		int mid=(l+r)>>1;
		if(qr<=mid)return query(lc,l,mid,ql,qr);
		if(mid<ql)return query(rc,mid+1,r,ql,qr);
		return query(lc,l,mid,ql,qr)(query(rc,mid+1,r,ql,qr));
	}
#undef lc
#undef rc
}

int n,L,R;

std::vector<int> G[N];
bool leaf[N],typ[N];
int key[N],lf[N],val[N],dep[N],fa[N];
int siz[N],son[N],top[N],bot[N],in[N],dfn;
int dp[N],ans[N],all=1;
num prod[N];

std::vector<int> modi[N];

void pre_dfs(int u,int p){
	leaf[u]=true;
	lf[u]=siz[u]=1;
	dep[u]=dep[p]+1;
	val[u]=dep[u]&1?1:n;
	for(int re v:G[u])if(v!=p){
		leaf[u]=false;
		pre_dfs(v,u);
		siz[u]+=siz[v],Mul(lf[u],lf[v]);
		if(siz[v]>siz[son[u]])son[u]=v;
		if(dep[u]&1){
			if(val[v]>val[u])val[u]=val[v],key[u]=v;
		}
		else {
			if(val[v]<val[u])val[u]=val[v],key[u]=v;
		}
	}
	if(leaf[u]){
		lf[u]=2;
		val[u]=u;
	}
}

void dfs(int u,int p,int tp,bool t,bool mx){
	fa[u]=p,in[u]=++dfn;
	typ[u]=t,prod[u]=1,top[u]=tp;
	if(leaf[u]){
		if(mx){
			dp[u]=2*(val[u]<=val[1]);
			if(val[u]<=val[1])modi[val[1]-val[u]+1].push_back(u);
		}
		else {
			dp[u]=2*(val[u]>=val[1]);
			if(val[u]>=val[1])modi[val[u]-val[1]+1].push_back(u);
		}
		SGT::modify(1,1,n,in[u],func(0,dp[u]));
	}
	if(son[u]){
		dfs(son[u],u,tp,!t,mx);
		bot[u]=bot[son[u]];
	}else bot[u]=u;
	for(int re v:G[u])if(v!=p&&v!=son[u]){
		dfs(v,u,v,!t,mx);
		if(t)prod[u]*=dp[v];
		else prod[u]*=dec(lf[v],dp[v]);
	}
	if(son[u]){
		if(t){
			dp[u]=mul(prod[u],dp[son[u]]);
			SGT::modify(1,1,n,in[u],func(prod[u],0));
		}
		else {
			dp[u]=mul(prod[u],dec(lf[son[u]],dp[son[u]]));
			dp[u]=dec(lf[u],dp[u]);
			SGT::modify(1,1,n,in[u],func(prod[u],lf[u]-mul(prod[u],lf[son[u]])));
		}
	}
}

void get_dfn(int u,int p){
	if(key[u]){
		get_dfn(key[u],u);
		for(int re v:G[u])if(v!=p&&v!=key[u]){
			dfs(v,u,v,false,dep[u]&1);
			Mul(all,dp[v]);fa[v]=0;
		}
	}
}

inline void modify(int u){
	SGT::modify(1,1,n,in[u],func(0,dec(dp[u],1)));
	int tmp=SGT::query(1,1,n,in[top[u]],in[bot[u]]).b;
	u=top[u];
	while(fa[u]){
		int p=fa[u];
		if(typ[p])prod[p]*=tmp,prod[p]/=dp[u];
		else prod[p]*=dec(lf[u],tmp),prod[p]/=dec(lf[u],dp[u]);
		dp[u]=tmp,u=p;
		if(typ[u])SGT::modify(1,1,n,in[u],func(prod[u],0));
		else SGT::modify(1,1,n,in[u],func(prod[u],dec(lf[u],mul(prod[u],lf[son[u]]))));
		tmp=SGT::query(1,1,n,in[top[u]],in[bot[u]]).b;
		u=top[u];
	}
	Mul(all,power(dp[u],mod-2,tmp));
	dp[u]=tmp;
}

signed main(){
#ifdef zxyoi
	freopen("minimax.in","r",stdin);
#endif
	n=gi(),L=gi(),R=gi();
	for(int re i=1;i<n;++i){
		int u=gi(),v=gi();
		G[u].push_back(v);
		G[v].push_back(u);
	}
	SGT::build(1,1,n);
	pre_dfs(1,0);get_dfn(1,0);
	for(int re i=1;i<n;++i){
		for(int re u:modi[i])modify(u);
		ans[i]=dec(lf[1],all);
	}
	ans[n]=dec(lf[1],1);
	for(int re i=n;i;--i)Dec(ans[i],ans[i-1]);
	for(int re i=L;i<=R;++i)cout<<ans[i]<<" ";
	return 0;
}
zxyoi_dreamer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python使用minimax算法实现五子棋
09-18
Python中的Minimax算法是用于决策树搜索的一种策略，常用于棋类游戏，如五子棋、国际象棋等。它的核心思想是通过模拟对手的最佳策略来评估每一步棋的可能结果，以找到最佳的下一步。在五子棋中，Minimax算法会尝试...
【LOJ3044】「ZJOI2019」Minimax 搜索
cz_xuyixuan的博客
04-02 1470
【题目链接】 点击打开链接 【思路要点】 首先考虑如何求出 PreiPre_iPrei​ 表示稳定度在 iii 以内的集合的个数，若求得 PreiPre_iPrei​ ，则有 Ansi=Prei−Prei−1Ans_i=Pre_i-Pre_{i-1}Ansi​=Prei​−Prei−1​ 。 注意到各叶子节点权值不同，其权值最后作为根节点权值的叶子结点是唯一的，记为 keykeykey...
「ZJOI2019」Minmax搜索
weixin_30550081的博客
07-25 86
传送门 Solution 叶子节点的变化区间是连续的，可得知非叶子节点的权值变化区间也是连续的 由此可知，\(W\)的变化值的可行域也是连续的，所以只需要看它能否变为\(W+1\)或\(W-1\) 对于答案，可以先求消耗能量不超过\(k\)的集合数\(ans_k\)，再进行查分 发现\(ans_1=2^{m-1},ans_n=2^{m}-1\) 首先发现，如果要将\(W\)的值...
「ZJOI2019」Minimax搜索-动态DP
DSL_HN_2002的博客
04-17 319
Description 链接 Solution 考虑差分，求出w(S)≤kw(S)\leq kw(S)≤k的集合数。 显然，www的值域是连续的。所以www只会变成w+1w+1w+1或w−1w-1w−1。 显然，w(S)≤1w(S)\leq 1w(S)≤1的集合数为2m−12^{m-1}2m−1，所以接下来讨论的时候默认www节点不会修改。 可以发现w(s)≤kw(s)\leq kw(s)≤k等...
【LOJ】#3044. 「ZJOI2019」Minimax 搜索
weixin_30443731的博客
06-03 147
LOJ#3044. 「ZJOI2019」Minimax 搜索 一个菜鸡的50pts暴力 设\(dp[u][j]\)表示\(u\)用\(j\)次操作能使得\(u\)的大小改变的方案数 设每个点的初始答案是\(S[u]\) 每个数大小只和\(S[1]\)的大小关系有关 于是每个数的状态设为-1（比S[1]小），1（比S[1]大），0（和S[1]一样） 状态里设的改变是指在这三种状态里的一种变...
UOJ#468. 【ZJOI2019】Minimax搜索 动态DP
weixin_30522095的博客
07-11 118
原文链接www.cnblogs.com/zhouzhendong/p/UOJ468.html 前言 毒瘤题 题解 首先，将问题稍加转化，将“等于k”转化为“小于等于k”减去“小于k”。 然后，考虑在有一个变化量限制k时，所有的叶子会怎样变化。 我们称原本根的权值对应的节点到根的路径为“主链”，那么，只要主链的任何一个节点的权值发生变化，那么根节点权值就发生变化。 我们称一个主链上的节点的...
chess-minimax:在Python中使用Minimax算法的国际象棋游戏
04-07
《Python中的国际象棋游戏与Minimax算法》 在信息技术领域，人工智能（AI）与游戏的结合一直是研究的热点。特别是在棋类游戏中，利用智能算法让计算机与人类进行对弈，不仅能展示AI的强大，也为玩家提供了新的挑战...
Connect4：使用minimax连接4个人工智能
02-16
AI For Connect 4 Connect 4 AI使用minimax算法和alpha beta修剪来搜索可能的最佳移动。 合并了一个转置表，用于存储以前的计算，并且随着转置表变大，迭代加深用于使AI搜索逐渐加深。 pygame模块用于GUI，在该GUI中...
TicTacToe:使用Winmaxs和minimax算法开发的TicTacToe游戏
04-17
《井字游戏：Winmaxs与Minimax算法的深度解析》 井字游戏，又称“三子棋”或“Tic Tac Toe”，是一款简单而有趣的双人策略游戏。在这个项目中，我们通过C#编程语言，结合Winforms图形界面和经典的Minimax算法，构建...
minimax_game_angular
04-30
总的来说，“minimax_game_angular”项目展示了如何结合AngularJS的动态性与minimax算法的智能决策，构建一个交互式的井字游戏。它不仅对于学习AngularJS的开发者提供了实践案例，也为研究人工智能和游戏策略的爱好...
【LOJ3042】「ZJOI2019」麻将
cz_xuyixuan的博客
04-02 2071
【题目链接】 点击打开链接 【思路要点】 首先考虑如何判断一副牌是否胡牌。 我们可以用动态规划来解决该问题，可以参考 【CodeForces】CodeForces Global Round 1 题解 一文中 DDD 题的解法，我们可以计算一副牌最多可以组成的面子数，再记一维状态表示是否组成过对子即可。 回到原题，我们将上述 dpdpdp 的状态、数值全部压入状态，看做当前 dpdpdp...
[ZJOI2019]Minimax搜索
weixin_30466953的博客
04-17 118
先求出根节点的权值\(w\)。根据套路，我们对于每个\(k\)，计算\(w(s)\leq k\)的方案数，差分得到答案。为了方便，接下来考虑计算概率而不是方案数。 可以发现，对于一个给定的有解的子集，在最优解下，根节点的权值一定可以是\(w+1\)或\(w-1\)。如果我们希望把根节点的权值变为\(w+1\)，那么我们一定只会改变点权\(\leq w\)的点，\(w-1\)同理。 我们特殊考虑点权...
镇海三日游——ZJOI2019游记
nan
03-29 1217
写在前面 突然想起来是时候(乱)写一篇游记了 我只是一只辣么弱的蒟蒻，jls你居然还忍心骗我说不是你出题。。。 Day0 在学校听完一个讲座后直接去了镇海，没去镇中。。。因为蒟蒻太菜了tg都打不到515 然后就去宾馆嗨皮了♂ 宾馆就在镇中走出100m左右，炒鸡近 然后。。也没有到多晚，颓了会儿Big Bang Theory Day1~3（自闭了） 大早上的，lyxlyxlyx神仙讲了《具体数学》...
Loj #3044. 「ZJOI2019」Minimax 搜索
weixin_34232617的博客
05-14 196
Loj #3044. 「ZJOI2019」Minimax 搜索 题目描述 九条可怜是一个喜欢玩游戏的女孩子。为了增强自己的游戏水平，她想要用理论的武器武装自己。这道题和著名的 Minimax 搜索有关。 可怜有一棵有根树，根节点编号为 \(1\)。定义根节点的深度为 \(1\)，其他节点的深度为它的父亲的深度加一。同时在叶子节点权值给定的情况下，可怜用如下方式定义了每一个非节点的权值： - 对于深...
【SPOJ2666】QTree4【链分治】
Lstdo的博客
08-10 373
传送门 题意：给一棵带边权的树，每个点开始时为白色，维护两种操作： 1.改变一个点的颜色（白变黑，黑变白） 2.询问最远的两个白点之间的距离 树分治国集论文 链分治的本质其实就是树链剖分。它们的区别是树剖维护路径询问，链分治维护全局路径。 动态点分治需要重新建一棵树，而链分治分出来的是链，本身就可以用数据结构维护。所以链分治本身就可以资瓷修改。 对于每一条链单独用数据结构维护与当前链有交集的路径信...
洛谷P4719 【模板】动态dp（链分治+ddp）
苟为蒟蒻又何妨
01-04 351
传送门 ddpddpddp模板题。 题意简述：给你一棵树，支持修改一个点，维护整棵树的最大带权独立集。 思路： 我们考虑如果没有修改怎么做。 貌似就是一个sbsbsb树形dpdpdp，fi,0f_{i,0}fi,0​表示不选iii的最大值，fi,1f_{i,1}fi,1​表示选iii的最大值。 那么可以这样从iii的儿子vvv转移过来： fp,0+=max{fv,0,fv,1},fp,1+=fv...
[ZJOI2019]开关
时光真疯狂, 我一路执迷于匆忙.
04-30 864
Description 有一个n位二进制数，一开始为0 每一轮中对于每一个i，有pi∑pip_i\over \sum p_i∑pi​pi​​的概率将这一位异或上1，每轮操作独立 问第一次变成目标状态的期望步数 n<=100,∑pi<=50000 Solution 考虑设F(x)表示在n步时变为目标状态的概率，显然有F(x)=∏epix+(−1)tie−pix2F(x)=\prod{e^...
ZJOI2019后记
zx2003的博客
04-01 1806
成绩咕到愚人节才出，游记也跟着咕成后记了。 晚上吃完饭后听说成绩出了，怀着忐忑不安的心看到自己0+100+30。 当时还没公布带联赛成绩的榜，操作了一波，发现成功忘掉打卡，鈤。 好像rk24。 把学车第六之后&初中生去掉后rk19。 打不过初中小哥&学车第六真丢脸 早上开场看T2，一眼线段树上维护边长lognlognlogn的矩阵。 四个logloglog可能就40分吧。 冷静了好...
Minimax C#
最新发布
07-28
Minimax is a popular algorithm used in game theory and artificial intelligence to determine the optimal move for a player in a game with perfect information. It is often used in games such as chess, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值