树论_1.

已于 2022-11-21 15:56:33 修改
阅读量197 收藏
点赞数
文章标签： 深度优先 算法 图论
于 2022-11-18 11:31:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cn_tigerhan/article/details/127897497
版权

树形dp来一个Maximum Weight Subset大部分其实都是cf的题了。
看看看。考虑从dp入手后大部分的树形dp都要记录两维，那么再看看不妨记 f[ x ][ i ]表示以x为根的子树中最近的那个选择了的点深度为j。
那么明显可以从子节点转移，如何？通过枚举深度即可。

#include<bits/stdc++.h>
using namespace std;
int n,m,k,len=0,last[100001],f[1001][1001],a[10001],tmp[1001];
struct pp
{
	int x,y,next;
};pp p[100001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
void dfs(int x,int fa)
{
	f[x][0]=a[x];
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;dfs(y,x);
		for(int j=0;j<=n;j++) tmp[j]=f[x][j];
		for(int j=0;j<=n;j++) 
		{
			for(int kk=max(k-j,0);kk<=n;kk++) tmp[min(j,kk+1)]=max(tmp[min(j,kk+1)],f[x][j]+f[y][kk]);
		}	
		for(int j=0;j<=n;j++) f[x][j]=tmp[j];
	}
	return ;
}
int main()
{
	memset(last,-1,sizeof(last));
	scanf("%d%d",&n,&k);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n-1;i++) 
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(x,y);ins(y,x); 
	}
	dfs(1,1);int ans=0;
	for(int i=0;i<=n;i++) ans=max(ans,f[1][i]);
	printf("%d",ans);
	return 0;
}

1-Trees and Queries，对于一个询问，可能的结果会有三种：
a->b, a -> x -> y -> b, a -> y -> x -> b。
那么考虑如何处理明显可以通过深度+lca爆杀。

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[100001],db[100001][30],dep[100001];
struct pp
{
	int x,y,next;
};pp p[400001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
} 
void dfs(int x,int fa)
{
	dep[x]=dep[fa]+1,db[x][0]=fa; 
	for(int i=1;(1<<i)<=dep[x];i++) db[x][i]=db[db[x][i-1]][i-1];
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dfs(y,x);
	}
	return ;
}
int getlca(int x,int y)
{
	if(dep[x]>dep[y]) swap(x,y);
	for(int i=20;i>=0;i--) 
	{
		if(dep[y]-(1<<i)>=dep[x]) y=db[y][i];
	}
	if(x==y) return x;
	for(int i=20;i>=0;i--)
	{
		if(db[x][i]!=db[y][i]) x=db[x][i],y=db[y][i];
	}
	return db[x][0];
} 
int getdep(int x,int y)
{
	return dep[x]+dep[y]-dep[getlca(x,y)]*2;
}
bool check(int x,int k)
{
	if(x>k||(x%2!=k%2)) return false;
	return true;
}
int main()
{
	memset(last,-1,sizeof(last));
	scanf("%d",&n);
	for(int i=1;i<=n-1;i++)
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(x,y);ins(y,x);
	}dfs(1,1);
	scanf("%d",&m);while(m--)
	{
		int a,b,x,y,k;scanf("%d%d%d%d%d",&x,&y,&a,&b,&k);
		int ab=getdep(a,b),ax=getdep(a,x),ay=getdep(a,y),bx=getdep(b,x),by=getdep(b,y),xy=getdep(x,y);
		if(check(ab,k)||check(ax+by+1,k)||check(ay+bx+1,k)) printf("YES\n");
		else printf("NO\n");
	}
	return 0;
}

Tree Queries,转化一下题面，发现每一个点其实都与它的父亲有关（又名若是要合法则父亲是必须的），那么题目可以转化成能否有一条从1到不知道哪个点的路径包含一些点，那么可以直接做了吧~好吧提一下我没想出来的点，也就是如何判断一个点是否在另一个点的子树内，怎么办呢，sb你树剖没学过嘛？

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[4000001],dfs_x=0,dfsx[4000001],siz[4000001],fa[4000001];
int a[4000001],dep[4000001];
struct pp
{
	int x,y,next;
};pp p[4000001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
void dfs(int x,int ff)
{
	dfsx[x]=++dfs_x;siz[x]=1;fa[x]=ff;dep[x]=dep[ff]+1;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(ff==y) continue ;
		dfs(y,x);siz[x]+=siz[y];
	}
	return ;
}
bool cmp(const int &x,const int &y)
{
	return dep[x]<dep[y];
}
bool check(int x,int y)
{
	if(dfsx[x]<=dfsx[y]&&dfsx[x]+siz[x]>dfsx[y]) return true;
	return false; 
}
int main()
{
	memset(last,-1,sizeof(last));
	int q;scanf("%d%d",&n,&q);
	for(int i=1;i<=n-1;i++)
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(x,y);ins(y,x);
	}dfs(1,1);
	while(q--)
	{
		int k;scanf("%d",&k);
		for(int i=1;i<=k;i++) scanf("%d",&a[i]),a[i]=fa[a[i]];
		sort(a+1,a+k+1,cmp);int pd=1;
		for(int i=1;i<=k-1;i++) 
		{
			if(!check(a[i],a[i+1])) pd=0;
		}
		if(pd) printf("YES\n");
		else printf("NO\n"); 
	}
	return 0;  
}

Maximum White Subtreedp？

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[1000001],f[1000001],a[1000001];
struct pp
{
	int x,y,next;
};pp p[1000001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
void dfs1(int x,int fa)
{
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dfs1(y,x);f[x]+=max(0,f[y]); 
	} 
	if(a[x]==0) f[x]--;
	else f[x]++; 
	return ;
}
void dfs2(int x,int fa)
{
	if(f[x]>0) f[x]=max(f[x],f[fa]);
	else f[x]=max(f[x],f[x]+f[fa]);
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dfs2(y,x);
	}
	return ;
}
int main()
{
	memset(last,-1,sizeof(last));
	scanf("%d",&n);
	for(int i=1;i<=n;i++) scanf("%d",&a[i]);
	for(int i=1;i<=n-1;i++)
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(x,y);ins(y,x);
	}
	dfs1(1,1);dfs2(1,1);
	for(int i=1;i<=n;i++) printf("%d ",f[i]);
	return 0;
}

Construct the Binary Tree有意思的构造题，不妨做做看？

//考虑构造，若是一颗二叉树，则距离最大应该是不断向下衍生的，所以链状的时候距离最长。
//那么最小的时候呢？便是满二叉树的时候，其实若是难以理解，你可以尝试从每一个点的贡献考虑
//说出了判断方法，从判断得到启发，那么考虑构造，想了两种：
//第一种首先我们可以假设整一个链，然后再向上移节点，不过实现很麻烦？
//第二种其实我们可以直接看大佬的。嗯不是我懒，主要是大佬nb 
//总结下伟大的思想，化简的方式很简单，并且发现其对二进制的应用：i&(i-1)来判断其是否到下层
//其次将最左的1 2 4 8作为链使用我是非常认可的。 
#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,sum,cnt=0,sumdep;
int dep[200011],fa[200011];
signed main()
{
	int t;scanf("%lld",&t);
	while(t--)
	{
		int pos ;memset(fa,0,sizeof(fa));memset(dep,0,sizeof(dep)); 
		scanf("%lld%lld",&n,&sumdep);dep[0]=-1;cnt=0;
		for(int i=1;i<=n;i++)
		{
			fa[i]=i>>1;dep[i]=dep[i>>1]+1;cnt+=dep[i];
			if((i&(i-1))==0) pos=i;//如果是更下一层，pos记录的是最低端 
		}
		sumdep-=cnt;
		if(sumdep<0) 	
		{
			printf("NO\n");
			continue ;
		}
		if(sumdep==0)
		{
			printf("YES\n");
			for(int i=2;i<=n;i++) printf("%lld ",fa[i]);
			printf("\n");continue ;
		}
		for(int i=n;i;i--)
		{
			if((i&(i-1))==0) continue ;
			sumdep-=dep[pos]-dep[i]+1;
			if(sumdep<=0)
			{
				while(sumdep) pos=fa[pos],sumdep++;
				sumdep=0;fa[i]=pos;break;
			}
        	fa[i]=pos,dep[i]=dep[pos]+1,pos=i;
		}
		if(sumdep) printf("NO\n");
		else 
		{
			printf("YES\n");
			for(int i=2;i<=n;i++) printf("%lld ",fa[i]);
			printf("\n");	
		}
	}
	return 0;
}

Village (Minimum)，Village (Maximum)欸这两道题怎么说呢我们先做最大值看看。

//这题我们应该考虑从边的贡献入手，考虑每条边最多能被经过几次，则对于左右两个点而言
//那么应该是min(siz[x],siz[y])*2，那么考虑如何达到理论上的最大值，发现min的值最多为n/2
//也就是说找一个点使其子树的最大值不超过n/2，这不禁让人想到一个东西——重心！
//那么明显肯定要从重心入手，想维护。
//呃呃呃考虑了半天，看了大佬的题解，发现因为找到了重心，将子树按dfsx扔入队列中 
//那么发现i与i+n/2是绝不在同一颗子树中的，所以直接这样维护即可，再想想证明，发现每个点都做到了最优贡献，所以这样维护是行的
#include<bits/stdc++.h>
#define int long long 
using namespace std;
int n,m,len=0,last[400001],maxx[400001],siz[400001],q[400001],tot=0;
int root,ans[400001],sum=0,dep[400001];
struct pp
{
	int x,y,next;
};pp p[400001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
void dfs1(int x,int fa)
{
	siz[x]=1;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dfs1(y,x);siz[x]+=siz[y];
		maxx[x]=max(maxx[x],siz[y]);
	}
	maxx[x]=max(maxx[x],n-siz[x]);
	if(!root||maxx[root]>maxx[x]) root=x;
	return ;
}
void dfs2(int x,int fa)
{
	dep[x]=dep[fa]+1;q[++tot]=x;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dfs2(y,x);
	}
	return ;
}
 main()
{
	memset(last,-1,sizeof(last));
	scanf("%lld",&n);root=0;
	for(int i=1;i<=n-1;i++)
	{
		int x,y;scanf("%lld%lld",&x,&y);
		ins(x,y);ins(y,x); 
	}
	dfs1(1,1);dep[root]=-1;dfs2(root,root);
	for(int i=1;i<=n/2;i++)
	{
		int x=q[i],y=q[i+n/2];
		sum+=(dep[x]+dep[y])*2;
		ans[x]=y;ans[y]=x;
	}
	if(n%2==1) 
	{
		int u=q[n];
		int v=q[1];
		int w=q[1+n/2];
		sum+=dep[u]*2;
		ans[u]=v;
		ans[v]=w;
		ans[w]=u;
//		ans[q[n]]=q[n];sum+=dep[q[n]]*2;
//		swap(ans[1],ans[n]);
	}
	printf("%lld\n",sum);
	for(int i=1;i<=n;i++) printf("%lld ",ans[i]);
	return 0;	
}

最小值是这个：感觉这个还麻烦点，因为需要一个重要结论就是先满足儿子再满足自己。

#include<bits/stdc++.h>
using namespace std;
int n,m,len=0,last[200001],ans[200001],sum=0;
bool v[200001];
struct pp
{
	int x,y,next;
};pp p[400001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ; 
}
void dfs(int x,int fa)
{
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y; if(y==fa) continue ;
		dfs(y,x);
		if(!ans[x]&&!ans[y]) ans[x]=y,ans[y]=x;
	}
	return ;
}
int main()
{
	memset(last,-1,sizeof(last));memset(v,false,sizeof(v));
	scanf("%d",&n);
	for(int i=1;i<=n-1;i++)
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(x,y);ins(y,x);
	}
	dfs(1,1);
	for(int i=1;i<=n;i++) 
	{
		if(ans[i]) 
		{
			sum++;
			continue ;	
		}
		int tmp=p[last[i]].y;
        ans[i]=ans[tmp];
        ans[tmp]=i;sum+=2;
	}
	printf("%d\n",sum);
	for(int i=1;i<=n;i++) printf("%d ",ans[i]);
	return 0;
}

P3354 [IOI2005]Riv 河流上一题人给我做麻了。这题dp还好说，不想说

#include<bits/stdc++.h>
#define int long long  
using namespace std;
int n,m,K,len=0,last[100001],dep[100001],f[101][101][101],g[101][101][101],wood[100001];
int q[100001],tot=0;
struct pp
{
	int x,y,c,next;
};pp p[1000001];
void ins(int x,int y,int c)
{
	int now=++len;
	p[now]={x,y,c,last[x]};last[x]=now;
	return ;
}
void dfs(int x)
{
	q[++tot]=x; 
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;//if(y==fa) continue ;
		dep[y]=dep[x]+p[i].c;dfs(y);
		for(int j=1;j<=tot;j++)
		{
			for(int k=K;k>=0;k--)
			{
				f[x][q[j]][k]+=f[y][q[j]][0];
				g[x][q[j]][k]+=f[y][x][0];
				for(int kk=0;kk<=k;kk++)
				{
					f[x][q[j]][k]=min(f[x][q[j]][k],f[x][q[j]][k-kk]+f[y][q[j]][kk]);
					g[x][q[j]][k]=min(g[x][q[j]][k],g[x][q[j]][k-kk]+f[y][x][kk]);
				} 
			}
		}
	}	
	for(int i=1;i<=tot;i++)
	{
		for(int k=0;k<=K;k++)	
		{
			if(k>=1) f[x][q[i]][k]=min(f[x][q[i]][k]+wood[x]*(dep[x]-dep[q[i]]),g[x][q[i]][k-1]);
			else f[x][q[i]][k]+=wood[x]*(dep[x]-dep[q[i]]);
		}
	}
	tot--;
	return ;	
}
signed main()
{
	memset(last,-1,sizeof(last));
	scanf("%lld%lld",&n,&K);
	for(int i=1;i<=n;i++)
	{
		int x=i,y,c;scanf("%lld%lld%lld",&wood[i],&y,&c);
		ins(y,x,c);//ins(x,y,c);
	}
	dfs(0);printf("%lld",f[0][0][K]);
	return 0; 
}

Johnny and Contribution在这里插入图片描述

#include<bits/stdc++.h> 
using namespace std;
int n,m,len=0,last[2000001];
bool v[2000001];
struct pp
{
	int x,y,next;
};pp p[2000001];
struct node
{
	int t,id;
};node e[2000001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
bool cmp(const node &x,const node &y)
{
	return x.t<y.t;
}
int main()
{
	memset(last,-1,sizeof(last));
	scanf("%d%d",&n,&m);int pd=1;
	for(int i=1;i<=m;i++)
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(x,y);ins(y,x); 
	}
	for(int i=1;i<=n;i++) scanf("%d",&e[i].t),e[i].id=i;
	for(int i=1;i<=n;i++)
	{
		memset(v,true,sizeof(v));
		for(int j=last[i];j!=-1;j=p[j].next) v[e[p[j].y].t]=false ;
		for(int j=1;j<e[i].t-1;j++) if(v[j]) printf("-1"),pd=-1;if(pd==-1) break;
		if(!v[e[i].t]) printf("-1"),pd=-1;if(pd==-1) break;
	}
	if(pd==-1) return 0;sort(e+1,e+n+1,cmp);
	for(int i=1;i<=n;i++) printf("%d ",e[i].id);
	return 0;
}

告一段落！
还没有呢！
P5958 [POI2017]Sabotaż

//明显的，因为一开始只有一个点，那么处于叶子节点是最多黑色节点的，考虑树形dp。
//令f[i]表示的是令i不是叛徒的最小的x，再设siz[x]表示子树大小，考虑转移。
//那么令f[i]表示的是令i不是叛徒的最小的x，其实就是令f[i]成为叛徒的最大值 
//那么我要是让一个点变黑色，需要的是要不就是子树的黑嘛？所以我们在(f[y],siz[x]/siz[y])取其小 
//让其满足自己被染黑，还能连带上父亲一起被染。所以直接这样转移就好啦
#include<bits/stdc++.h>
using namespace std;
int n,m,k,len=0,last[500001],siz[500001];double f[500001],ans=0;
struct pp
{
	int x,y,next;
};pp p[1000001];
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
}
void dfs(int x,int fa)
{
	siz[x]=1;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;
		dfs(y,x);siz[x]+=siz[y];
	}
	if(siz[x]==1) f[x]=1.0;
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;if(y==fa) continue ;//printf("%lf %lf %lf\n",f[x],f[y],(double)(siz[x]-1)/siz[y]);
		f[x]=max(f[x],min(f[y],(double)(siz[y])/(siz[x]-1)));
	}
	if(siz[x]>k) ans=max(ans,f[x]);//printf("%d %d\n",x,siz[x]);
	return ;
} 
int main()
{
	memset(last,-1,sizeof(last));
	scanf("%d%d",&n,&k);
	for(int i=2;i<=n;i++)
	{
		int x,y;scanf("%d",&x);
		ins(x,i);ins(i,x); 
	}
	dfs(1,1);printf("%.8lf",ans);
	return 0;
}
cn_tigerhan
关注
2022年美赛获奖E类论文_2202666.pdf
03-10
##### 1. **森林碳汇模型** 该模型主要关注于森林作为碳汇的能力。论文首先建立了一个基于面积、不同树种的碳汇能力和树木年龄的时间序列模型来计算活树的碳汇量。这个模型考虑到了随着时间的推移，不同树种的碳汇...
树论
u012803274的博客
08-13 456
符号表：描述一张抽象的表格，我们将信息（值）存储在其中，然后按照指定的键来搜索获取这些信息。符号表的实现方式： 1，BST二叉查找树(binary search tree)： 数据结构：节点。每个节点只有一个父节点（除了根节点没有父节点），并且每个节点都只有左右两个链接，分别指向自己的左子节点和右子节点。还包含一个键和一个值。键是有顺序的。 特性：一个二叉查找树是一棵二叉树。其中每个节点都含...
树论讲解（1）——树基础
weixin_34233618的博客
05-06 190
树是什么东西？？ 这个？？　　　　　　　　　　　　　　　　　　　　　　还是这个？？ 很显然身为一名c++选手，所说的树显然不是这个树了！！ 有人不禁要问，那树是什么东西呢？？？ 好，下面我们就来讲讲树的基本概念 one.树的定义 所谓树状图是一数据结构。它由n果然有限接点组成的就有一定层次关系的集合，把它叫做树，是因为它看起来像一棵倒挂的树。也...
数据结构与算法（三）：树论（树形结构、二叉树、二叉搜索树、红黑树、Btree&B+Tree、赫夫曼树、堆树）
Men-DD
04-24 1475
数论（树形结构、二叉树、二叉搜索树、红黑树、Btree、B+Tree、赫夫曼树、堆树）
树论基础-二叉树
@龙猫的博客
10-31 416
在树形结构里面有几个重要的术语： 1.结点：树里面的元素。 2.父子关系：结点之间相连的边 3.子树：当结点大于1时，其余的结点分为的互不相交的集合称为子树 4.度：一个结点拥有的子树数量称为结点的度 5.叶子：度为0的结点 6.孩子：结点的子树的根称为孩子结点 7.双亲：和孩子结点对应 8.兄弟：同一个双亲结点 9.森林：由N个互不相交的树构成森林 在树形结构里面有几个重要的术语： 结点的高度：结点到叶子结点的最长路径 结点的深度：根结点到该结点的边个数 结点的层数：结点的深度加1 树的高度：根结点的高.
算法与数据结构八日谈之四——树论
Starry__Night的博客
07-04 1389
1.树的定义父节点、子节点、子树、祖先、后代、兄弟、根节点、叶节点、路径等2.生成树生成树的计数Matrix-Tree定理最小(大)生成树-Prim算法 -Kruskal算法 部分维护动态图的题目可通过离线处理转化为维护最小生成树3.树的重心定义(性质)1:到树上所有点的距离和最小的点定义(性质)2:割掉该点后最大的子树大小最小的点-可通过递归处理树的重心来完成动态树分治 加权重心与平权重心求
2022年美赛获奖F类论文_2204803.pdf
03-10
1. **逻辑树分析**：通过麦肯锡逻辑树分析法找出衡量国家发展程度和全球公平性的必要指标。 2. **熵权法**：利用熵权法计算各项指标的权重。 3. **国家发展水平指数(NDI)**：基于加权求和的方法计算每个国家的NDI。 ...
2022年美赛获奖E类论文_2203489.pdf
03-10
1. **树生物量对数增长模型**：为了量化活体森林的生物量变化，作者采用了一种树生物量对数增长模型。这种模型可以用来估计森林在特定时间内能积累多少生物质。模型中包含了时间、初始条件以及其他可能影响生长的...
2020_Weekend1_Problems.zip
02-14
本压缩包“2020_Weekend1_Problems.zip”包含了当年第一周末A、D、E三个题目的PDF文件以及D题的相关数据表，为我们提供了深入研究这些算法问题的宝贵资料。 首先，让我们聚焦A题。这个题目可能涉及的是实际问题的...
计算机毕业设计大全3(论文)_kaic.zip
最新发布
04-18
1. **基于UNREAL DEVELOPMENT KIT的冒险类游戏**：Unreal Development Kit（UDK）是一款强大的游戏开发工具，主要使用C++编程语言。设计此类游戏涉及3D建模、物理引擎、AI系统、图形渲染和网络功能的实现。 2. **...
最全面的算法竞赛的树论知识
03-26
本文件包含了主要的算法竞赛中需要用到的有关树这一数据结构的知识
图论（树论）
zsyz_ZZY的博客
08-26 562
图论（树论）
树论相关
C'est la vie!
12-02 299
树的直径 定义：对于一颗无根树，找到两个点，使得他们之间的距离最远，这个距离就是树的直径。 求法： 两次bfs或dfs(O(n))：第一次以任意节点 x 为根，求出距离最远点 y，这个点一定在树的直径上（证明：树的直径求法及证明），第二次以这个点为根跑出来的最远点 z，y 与 z 的距离，就是树的直径。 树形 dp(O(n)) ：dp[ i ]表示经过 i 点的最长链长度。 性质： 直径两端...
[树论]JZOJ 2745 这是一棵树吗?
weixin_30485379的博客
01-18 123
传送门 Description DD和QQ在玩游戏，DD在地上画了一棵树（图论中的树），然后他告诉QQ这棵树的度数序列。QQ马上说这不是一棵树。DD认为自己被QQ鄙视了，他们吵了起来。 但DD随后发现自己算错了度数序列，QQ说的是对的。DD很奇怪为什么QQ反应得这么快。 现在给出一个图的度数序列，你需要做的就是像QQ一样：判断这是否可能是一棵树的度数序列。 题解 我们...
[转]C#与数据结构--树论--平衡二叉树(AVL Tree)
weixin_34354173的博客
10-08 234
   C#与数据结构--树论--平衡二叉树(AVL Tree) http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html 介绍 我们知道在二叉查找树中，如果插入元素的顺序接近有序，那么二叉查找树将退化为链表，从而导致二叉查找树的查找效率大为降低。如何使得二叉查找树无论在什么样情况下都能使它的形态最大限度地接近...
树论基本操作-建立二叉树以及相关概念
天道酬勤
02-01 161
package com.redis.binary; /** * 结点高度:结点到叶子节点的最长路径 * 结点深度:跟结点到该结点边的个数 * 结点层次:结点深度+1; * 树的高度:根结点的高度 * 常见的二叉树: * 平衡二叉树 * 二叉查找树 * 平衡二叉树 * B树:是多叉树,是根据二叉树演变而来 */ public class BinaryTree { //...
C#与数据结构--树论--平衡二叉树(AVL TREE)
压碎起重机
04-24 938
http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html
树论入门
cj1064789374的博客
12-13 641
树论入门
二叉树的基本操作
热门推荐
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
深度解析AVL树：自平衡二叉查找树的发明与应用
AVL树的特点在于它能够保持平衡，即任何节点的两个子树的高度最大差别为1。这种特性使得AVL树在增加、删除和查找节点时，最坏情况下依然能够保持对数时间复杂度，因此它比一般的二叉查找树更加高效。AVL树的主要用途...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值