7.23模拟赛总结 [数据结构优化dp] + [神奇建图]

最新推荐文章于 2024-10-06 07:30:01 发布
最新推荐文章于 2024-10-06 07:30:01 发布
阅读量1k 收藏 24
点赞数 19
分类专栏： TY 集训总结 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56326461/article/details/140646490
版权

目录

复盘

浅复盘下吧…

7:40 开题

看 T1 ，起初以为和以前某道题有点像，子序列划分，注意到状态数很少，搜出来所有状态然后 dp，然后发现这个 T1 和那个毛关系没有

浏览了一下，感觉 T2 题面又臭又长，意思也很恶心；T3 树上 ds 看上去很亲切；T4 一眼就不太可做

回来看 T1，发现很 sb，每次肯定贪心选最优的后缀，至于选 m 的限制，填满一段后再贪心往前选就行

8:04 码完了，小样例顺利过掉，一测大样例发现小数点后面不对，想了想应该不会是精度问题，可能做法假了

然后 不断证明结论+修改一些毫无影响的细节，仍然和大样例不上，最后决定把题面重读一遍，知道看到了 “相对误差”，6，突然想到我学过高中物理。。。到 8:50 才交上去

快开 T2，朴素的想法当然是 二维状态记 Max，但这个显然不太有优化空间（这种状态设计只有 i − 1 i-1 i−1 到 i i i 只有 O ( 1 ) O(1) O(1) 个决策需要单点修改时才能优化)

那么很快想到改成 f i f_i fi​ 一维状态，钦定 i i i 必选，往前找一个合法的，发现可以接上去的区间可以预处理出来，那么只需找 [ l , r ] [l,r] [l,r] 内小于 a i a_i ai​ 的最优决策… 三维偏序？树套树警告！

算了，先打暴力，竟然有 O ( 1 ) p t s O(1) pts O(1)pts 的高分，然鹅被一个 sb 细节卡住一直到 9:30 仍没调过，决定先看 T3

一眼发现是 sb 题，直接树上主席树就做完了，直接决定开码，10:30 过了小样例

然鹅大样例又挂了，反复调根本不明白怎么回事，一度以为自己主席树板子假了

最后突然想着把数组开大一倍，卧槽对了，不爆 RE 直接 WA 是吧，浪费了高达 O ( n ) O(n) O(n) 的时间

11:00 了，先把 T1 暴力调了吧，发现弱智错误… 然后看看能不能写点性质，得到了高达 5 p t s 5pts 5pts 的性质分

最后想 T2 感觉写不完，决定开 T4 暴力

最后获得了高达 7 p t s 7pts 7pts 的暴力分，赢！

所以 100+53+100+7=260 , rk O ( 2 n ) O(2^n) O(2n)

题解

T2

在这里插入图片描述
在这里插入图片描述
其实离正解不远了，回顾一下转移：

f i = m a x ( f j + 1 ) f_i=max(f_j+1) fi​=max(fj​+1)，其中 j < i , a j < a i j<i,a_j<a_i j<i,aj​<ai​ 且 i , j i,j i,j 可以通过小于 a i a_i ai​ 的数 “连接” 起来

直接三维偏序做也没错，但是本题可以有更多性质

注意到：能转移的决策满足 a j < a i a_j<a_i aj​<ai​，能连接其它数的数也是 a j < a i a_j<a_i aj​<ai​ ，二者可以同时维护

那么我们转到值域上做，从小到大插入新决策

每次处理询问时相当于要找连续段，这个可以 s e t set set 做（更好做法是并查集，但是我不会）；然后询问区间 Max，线段树维护

遇到偏序问题可以尝试 在最外层换一维关键字排序，会有意想不到的效果

#include<bits/stdc++.h>
using namespace std ;

typedef long long LL ;
const int N = 3e5+100 ;

int n , D , a[N] ;
int f[N] , rhk[N] ;
struct Segtree
{
	int l , r , Max ;
}t[4*N] ;
bool cmp( int x , int y )
{
	return a[x] < a[y] ;
}
void build( int p , int l , int r )
{
	t[p].l = l , t[p].r = r ;
	if( l == r ) {
		return ;
	}
	int mid = ( l + r ) >> 1 ;
	build( p<<1 , l , mid ) ; build( p<<1|1 , mid+1 , r ) ;  
}
int ask( int p , int l , int r )
{
	if( l <= t[p].l && t[p].r <= r ) {
		return t[p].Max ;
	}
	int mid = ( t[p].l + t[p].r ) >> 1 , Max = 0 ;
	if( l <= mid ) Max = max( Max , ask(p<<1,l,r) ) ;
	if( r > mid ) Max = max( Max , ask(p<<1|1,l,r) ) ;
	return Max ;
}
void modify( int p , int x , int d )
{
	if( t[p].l == t[p].r ) {
		t[p].Max = max( t[p].Max , d ) ;
		return ;
	}
	int mid = ( t[p].l + t[p].r ) >> 1 ;
	if( x <= mid ) modify( p<<1 , x , d ) ;
	else modify( p<<1|1 , x , d ) ;
	t[p].Max = max( t[p<<1].Max , t[p<<1|1].Max ) ;
}
struct node
{
	int l , r ;
	friend bool operator < ( node x , node y ) {
		return x.r < y.r ;
	}
};
set<node> s ; // 维护连续段 
int query( int x ) // 查 x 可用决策 
{
	int P = max(1,x-D) ;
	auto it = s.lower_bound((node){0,P}) ;
	if( it == s.end() ) {
		return 0 ;
	}
	return ask( 1 , min(it->l,P) , x-1 ) ;
}
void Insert( int x )// 插入决策 x 
{
	modify( 1 , x , f[x] ) ;
	if( s.empty() ) {
		s.insert((node){x,x}) ;
		return ;
	}
	auto it = s.lower_bound((node){0,x}) ;
	int L = x , R = x , fg = 0 ;
	if( it != s.end() ) {
		if( x < it->l ) {
			if( x+D >= it->l ) {// 接上了
				R = it->r ;
				fg = 1 ;
			} 
			if( it != s.begin() ) {
				auto iit = it ;
				iit -- ;
				if( iit->r + D >= x ) {
					L = iit->l ;
					s.erase( iit ) ;
				}
			}
			if( fg ) s.erase( it ) ;
			s.insert((node){L,R}) ;
		}
		return ;
	}
	it -- ;
	if( it->r+D >= x ) {
		L = it->l ;
		s.erase( it ) ;
	}
	s.insert((node){L,x}) ;
}

int main()
{
	scanf("%d%d" , &n , &D ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		scanf("%d" , &a[i] ) ; 
		rhk[i] = i ;
	}
	// 转移有两维限制，按值域做，去掉一维
	sort( rhk+1 , rhk+n+1 , cmp ) ;
	build( 1 , 1 , n ) ;
	int ans = 0 ;
	for(int i = 1 ; i <= n ; i ++ ) {
		int j = i ;
		f[rhk[i]] = query( rhk[i] ) + 1 ;
		while( j+1 <= n && a[rhk[j]] == a[rhk[j+1]] ) {
			j ++ ;
			f[rhk[j]] = query( rhk[j] ) + 1 ;
		}
		for(int k = i ; k <= j ; k ++ ) {
			Insert( rhk[k] ) ;
		}
		i = j ;
	}
	for(int i = 1 ; i <= n ; i ++ ) {
		ans = max( ans , f[i] ) ;
	}
	printf("%d" , ans ) ;
	return 0 ;
}

其实很好写

 

T4

神奇题
在这里插入图片描述
尝试 d p dp dp ，发现根本做不了…

根据我们的经验，遇到十分之抽象且题面又臭又长又不知所云的题目大多是图论，所以这题考虑建图

额

老师讲的一个建图出发点：注意到最终序列中每个值 要么由 a a a 提供，要么由 b b b，这种 “由 A 或由 B” 的问题是有二分图的样子的，考虑分左右两部，对于每个 i i i，将左部 a i a_i ai​ 与 右部 b i b_i bi​ 连边

我理解的：题目中给的 划分 实际上约束是很多的，我们考虑最初选所有 a a a 中的集合，然后用 b b b 中的若干个集合替换，这样 替换者的并 和 被替换者的并 必须是一样的，想换掉某个子集 a [ ] a[] a[] 的话，必须选择 所有 包含 b b b 中对应位置 的区间，然后对应回来 a a a 中区间也必须选… 如此往复（口胡）

我们尝试形式化的去描述这个东西，发现正可以用上面那种建边方式来描述 ，一个连通块就代表了 可以相互替换的一组 a [ ] , b [ ] a[],b[] a[],b[]

对于 K = 0 K=0 K=0，我们直接对于每个连通块取较小的那一组替换

对于 K = 1 K=1 K=1，考虑枚举边，分讨一下：

若断的是非割边，然后连到另一个连通块，这样贡献的变化是 m i n ( a , b ) + m i n ( c , d ) → m i n ( a + c , b + d ) min(a,b)+min(c,d)\to min(a+c,b+d) min(a,b)+min(c,d)→min(a+c,b+d)

显然有不等式 m i n ( a , b ) + m i n ( c , d ) ≤ m i n ( a + c , b + d ) min(a,b)+min(c,d)\leq min(a+c,b+d) min(a,b)+min(c,d)≤min(a+c,b+d)，所以贡献不会变小，断开一定不优

这个不等式也告诉我们，要尽可能拆连通块，尽可能不合并连通块

若断割边，我们最好的当然是连回本身，只拆，不合并

注意！这里有一个 conner，如果一个连通块只有两个节点 u , v u,v u,v 怎么办？我们显然没办法把 u u u 向自己连边

然而有这么一个事情：不妨设 u u u 为左部点，那么一定可以把 u u u 连到一个 左部点数不小于右部点的连通块上（找不到的话考虑右部点 v v v ），当 n ≥ 1 n\geq 1 n≥1 时，这样的连通块一定能找到

当 n = 1 n=1 n=1，直接特判 答案为 1 1 1 即可

对于 K = 2 K=2 K=2，与上面相反，需要 尽可能合并连通块，尽可能不拆连通块

对于一个连通块，如果有 非割边 ，那么用它一定比用割边更优，因为不会拆，且能够合并

下面考虑应该和哪个连通块合并，对于两个连通块 ( a 1 , b 1 ) (a_1,b_1) (a1​,b1​) , ( a 2 , b 2 ) (a_2,b_2) (a2​,b2​)

若 a 1 < b 1 , a 2 < b 2 a_1<b_1,a_2<b_2 a1​<b1​,a2​<b2​ （不等号方向相同）：

贡献变化 m i n ( a 1 + a 2 , b 1 + b 2 ) − m i n ( a 1 , b 1 ) − m i n ( a 2 , b 2 ) = 0 min(a_1+a_2,b_1+b_2)-min(a_1,b_1)-min(a_2,b_2)=0 min(a1​+a2​,b1​+b2​)−min(a1​,b1​)−min(a2​,b2​)=0，没影响

若 a 1 < b 1 , a 2 > b 2 a_1<b_1,a_2>b_2 a1​<b1​,a2​>b2​ （相反）

贡献变化 m i n ( a 1 + a 2 , b 1 + b 2 ) − m i n ( a 1 , b 1 ) − m i n ( a 2 , b 2 ) min(a_1+a_2,b_1+b_2)-min(a_1,b_1)-min(a_2,b_2) min(a1​+a2​,b1​+b2​)−min(a1​,b1​)−min(a2​,b2​)

= m i n ( a 1 + a 2 , b 1 + b 2 ) − a 1 − b 2 =min(a_1+a_2,b_1+b_2)-a_1-b_2 =min(a1​+a2​,b1​+b2​)−a1​−b2​
= m i n ( a 2 − b 2 , b 1 − a 1 ) =min(a_2-b_2,b_1-a_1) =min(a2​−b2​,b1​−a1​)
= m i n ( Δ 1 , Δ 2 ) =min(\Delta_1,\Delta_2) =min(Δ1​,Δ2​)

当 a 1 , b 1 a_1,b_1 a1​,b1​ 确定时，要找一个不等号相反，且差最大的，直接扫一遍记 Max 就行

如果全是割边，我们直接遍历这棵缩点后的树，依次断开每条树边即可

不太好写

#include<bits/stdc++.h>
using namespace std ;

typedef long long LL ;
const int N = 2e5+100 ; 

int T , K , M1 , M2 ;
int n , a[N] , b[N] ;
struct nn
{
	int lst , to ;
}E[2*N] ;
int head[2*N] , tot = 1 ;
inline void add( int x , int y )
{
	E[++tot] = (nn){ head[x] , y } ;
	head[x] = tot ;
}
int dfn[2*N] , low[2*N] , tim ;
bool bri[2*N] ;
vector<int> e[2*N] ;
void tarjan( int x , int inE )
{
	dfn[x] = low[x] = ++tim ;
	for(int i = head[x] ; i ; i = E[i].lst ) {
		int t = E[i].to ;
		if( !dfn[t] ) {
			tarjan( t , i ) ;
			low[x] = min( low[x] , low[t] ) ;
			if( low[t] > dfn[x] ) {
				bri[i] = bri[i^1] = 1 ;
			}
		}
		else if( i != (inE^1) ) {
			low[x] = min( low[x] , dfn[t] ) ;
		}
	}
}
int cnt , bol , bel[2*N] , A[2*N] , B[2*N] , SA[2*N] , SB[2*N] ;
void dfs( int x )
{
	bel[x] = cnt ;
	if( x <= M1 ) A[cnt] ++ ;
	else B[cnt] ++ ;
	for(int i = head[x] ; i ; i = E[i].lst ) {
		int t = E[i].to ;
		if( bri[i] ) {
			if( bel[t] ) {
				e[bel[t]].push_back( bel[x] ) ;
				e[bel[x]].push_back( bel[t] ) ;
			}
		}
		else if( !bel[t] ) dfs( t ) ;
	}
}
int PA[2*N] , PB[2*N] , ans1 , ans2 , ans3 , rt[2*N] ;
bool can[2*N] ; // 是否有非割边 
void get_size( int x , int fa )
{
	SA[x] = A[x] , SB[x] = B[x] ;
	if( A[x]+B[x] > 1 ) can[bol] = 1 ;
	for(int t : e[x] ) {
		if( t == fa ) continue ;
		get_size( t , x ) ;
		SA[x] += SA[t] ; SB[x] += SB[t] ;
	}
}
void ddfs( int x , int fa )
{
	for(int t : e[x] ) {
		if( t == fa ) continue ;
		ans2 = max( ans2 , min(PA[bol],PB[bol])-min(SA[t],SB[t])-min(PA[bol]-SA[t],PB[bol]-SB[t]) ) ; // 最多减少多少 
		ddfs( t , x ) ;
	}
}
int I , Mx1 , Mx2 ;
inline int V ( int a , int b , int c , int d ) // 合并后增加多少 / 拆开后损失多少 
{
	return min(a+c,b+d)-min(a,b)-min(c,d) ;
}
inline int V1( int a , int b )
{
	if( a > b ) return min(a-b,Mx2) ;
	return min(b-a,Mx1) ;
}
void Get( int x , int fa ) // 处理割边 
{
	for(int t : e[x] ) {
		if( t == fa ) continue ;
		ans3 = max( ans3 , -V(SA[t],SB[t],PA[I]-SA[t],PB[I]-SB[t])+V1(SA[t],SB[t]) ) ;
		ans3 = max( ans3 , -V(SA[t],SB[t],PA[I]-SA[t],PB[I]-SB[t])+V1(PA[I]-SA[t],PB[I]-SB[t]) ) ;
		Get( t , x ) ;
	}
}
void solve()
{
	cnt = 0 ; bol = 0 ;
	for(int i = 1 ; i <= M1+M2 ; i ++ ) {
		if( !dfn[i] ) {
			tarjan( i , 0 ) ;
		}
	}
	for(int i = 1 ; i <= M1+M2 ; i ++ ) {
		if( !bel[i] ) {
			cnt ++ ;
			dfs( i ) ;
		}
	}
	ans1 = ans2 = ans3 = 0 ;
	for(int i = 1 ; i <= cnt ; i ++ ) {
		if( !SA[i]&&!SB[i] ) {
			bol ++ ;
			rt[bol] = i ;
			get_size( i , 0 ) ;
			PA[bol] = SA[i] , PB[bol] = SB[i] ;
			ddfs( i , 0 ) ;
			ans1 += min(PA[bol],PB[bol]) ;
		}
	}
	ans2 = ans1-ans2 ;
	if( K == 0 ) {
		printf("%d\n" , ans1 ) ;
		return ;
	}
	if( K == 1 ) {
		printf("%d\n" , ans2 ) ;
		return ;
	}
	if( K == 2 ) {
		Mx1 = 0 , Mx2 = 0 ;
		if( M1 < n ) Mx1 = 1 ;
		if( M2 < n ) Mx2 = 1 ;
		for(int i = 1 ; i <= bol ; i ++ ) {
			Mx1 = max( Mx1 , PA[i]-PB[i] ) ;
			Mx2 = max( Mx2 , PB[i]-PA[i] ) ;
		}
		for(int i = 1 ; i <= bol ; i ++ ) {
			if( can[i] ) {
				if( PA[i] > PB[i] ) ans3 = max( ans3 , min(PA[i]-PB[i],Mx2) ) ;
				else ans3 = max( ans3 , min(PB[i]-PA[i],Mx1) ) ;
			}
			else {
				I = i ;
				Get( rt[i] , 0 ) ;
			}
		}
		printf("%d\n" , ans3+ans1 ) ;
		return ;
	}
}
int nam[N][2] ;	
void Clear()
{
	for(int i = 2 ; i <= tot ; i ++ ) bri[i] = 0 ;
	tot = 1 ;
	for(int i = 1 ; i <= M1+M2 ; i ++ ) head[i] = dfn[i] = bel[i] = 0 ;
	for(int i = 1 ; i <= n ; i ++ ) nam[i][0] = nam[i][1] = 0 ;
	tim = 0 ; 
	for(int i = 1 ; i <= cnt ; i ++ ) e[i].clear() , A[i] = B[i] = SA[i] = SB[i] = 0 ;
	for(int i = 1 ; i <= bol ; i ++ ) can[i] = 0 ; 
}

int main()
{
	scanf("%d%d" , &T , &K ) ;
	while( T -- ) {
		scanf("%d" , &n ) ;
		if( n == 1 ) {
			printf("1\n") ;
			for(int i = 1 ; i <= n ; i ++ ) scanf("%d" , &a[i] ) ;
			for(int i = 1 ; i <= n ; i ++ ) scanf("%d" , &b[i] ) ;
			continue ;
		}
		M1 = 0 , M2 = 0 ;
		for(int i = 1 ; i <= n ; i ++ ) {
			scanf("%d" , &a[i] ) ;
			if( !nam[a[i]][0] ) {
				nam[a[i]][0] = ++M1 ;
			}
			a[i] = nam[a[i]][0] ;
		}
		for(int i = 1 ; i <= n ; i ++ ) {
			scanf("%d" , &b[i] ) ;
			if( !nam[b[i]][1] ) {
				nam[b[i]][1] = ++M2 ;
			}
			b[i] = nam[b[i]][1] ;
			add( a[i] , b[i]+M1 ) , add( b[i]+M1 , a[i] ) ;
		}
		solve() ;
		Clear() ;
	}
	return 0 ;
}
癹魃♭
关注
专栏目录
数据结构实验Anyview上机通过答案
04-14
7.23.c和7.22.c可能涉及更高级的数据结构，如堆（用于优先队列）或堆排序，或者是某种特定的树结构如B树或B+树，这些数据结构在数据库索引和文件系统中广泛应用。 每个.c文件代表一个具体的问题或任务，可能涵盖了...
数据结构实验Anyview上机通过答案(必做+部分选做)
10-01
数据结构是计算机科学中的核心课程之一，它研究如何在计算机中高效地组织和管理数据。在本实验中，我们关注的是使用Anyview工具进行数据结构的上机实践。Anyview是一款专门为学习数据结构设计的软件，它提供了友好的...
数据结构——第7章 数据结构 第七章anyview系统作业答案
05-04
数据结构在计算机科学中扮演着核心角色，它们是组织、管理和处理信息的关键工具。本问题主要探讨了在图数据结构中如何通过深度优先搜索（DFS）和广度优先搜索（BFS）策略来判断是否存在从顶点vi到顶点vj的路径。 ...
广东工业大学 数据结构 anyview 作业系统 第七章答案
11-18
"数据结构中图的搜索策略和实现" 在数据结构中，图的搜索策略是指从给定的起始顶点出发，按照某种规则访问图中的顶点和边，以达到搜索图的目的。常见的图搜索策略有深度优先搜索（DFS）和广度优先搜索（BFS）。 ...
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 381
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之AVL树（万字详解）
都市隸人的博客
09-29 1121
本文介绍了数据结构中的AVL树，给出了C++的代码实现
【笔记】数据结构12
m0_52024881的博客
09-29 529
看到的社区的一个知识总结，这里记录一下。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1253
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 387
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
深入理解 C# 中的集合与数据结构
qq_45728381的博客
10-02 1328
在日常开发中，集合与数据结构是处理数据的基础工具。C# 提供了一系列强大而灵活的集合类型，帮助我们存储、访问和管理数据。这篇文章将带你了解 C# 中常用的数组、列表、字典、队列、栈、集合和链表的特性和用法。
数据结构之图（6）
2301_76246515的博客
10-05 724
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
每日学习一个数据结构-默克尔树（Merkle Tree）
最新发布
wendao76的专栏
10-06 716
默克尔树（Merkle Tree），也称为哈希树，是一种二叉树结构，广泛应用于数据验证和完整性检查。它在区块链技术中尤为常见，但也有其他应用场景。默克尔树通过层次化的哈希结构，提供了高效、安全的数据完整性验证机制。它在区块链、分布式系统、网络安全等多个领域都有广泛的应用。理解默克尔树的工作原理和应用场景，有助于在实际开发中选择合适的工具和技术。希望这些解释对你有所帮助！如果有任何具体的问题或需要进一步的解释，请随时提问。
数据结构篇（绪论）
wlcass zhengge blog
10-05 438
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
王道408考研数据结构-图-第六章
qq_55882840的博客
10-02 1003
6.1 图的基本概念6.1.1 图的定义图G由顶点集V和边集 E组成，记为G=(V,E),其中 V(G)表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系(边)集合。若V={v?,v?,…,vn},则用|M表示图G中顶第6章 点的个数，E={(u,v) | uεV,vεV},用|E|表示图G中边的条数。1.有向图若E是有向边(也称弧)的有限集合，则图G为有向图。弧是顶点的有序对，记为,其中 v,w是顶点，v称为弧尾，w称为弧头，称为从v到 w的弧，也称v邻接到 w。
18年408数据结构
weixin_62182040的博客
09-28 1038
如图所示：因为只存上三角部分的元素（包含对角线元素），经分析可知第一层存12个元素，第二层存11个元素，第三层存10个元素，第四层存9个元素，第五层存8个元素，接着第6层只存m6,6，一共是12+11+10+9+8+1=51.A.1出队并输出，2出队并输出，345存入栈中，5出栈并输出，6出队并输出，4出栈并输出，3出栈并输出，A正确。B.1出队入栈，2出队并输出，3出队并输出，4出队并输出，5出队并输出，6出队并输出,1出栈并输出。此时储存在数组中的序列是：6,9,7,1,8,4,5，排除D。
每日学习一个数据结构-AVL树
wendao76的专栏
10-03 751
AVL树是一种自平衡的二叉查找树，由两位俄罗斯数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明。定义：AVL树是一种二叉查找树，其中每个节点的左右子树的高度差的绝对值（即平衡因子）不超过1。特性左右子树都是AVL树。左右子树高度之差（简称平衡因子）的绝对值不超过1（-1、0、1）。任意节点的左右子树的高度差不会超过1，这保证了树的高度相对较低，从而提高了搜索、插入和删除操作的效率。
【初阶数据结构】排序——选择排序
2301_77112794的博客
09-28 444
本文主要讲了选择排序，分别是直接选择排序和堆排序
数据结构-3.7.双端队列
ADCvbV的博客
10-01 573
双端队列也可以是只在一端删除和添加，此时就是栈；双端队列在一端添加，另一端输出，此时就是队列；共有24种排列方式：2，4，1，3不行，因为4出栈时说明3已经入栈了，下一个出栈的只能是3，而不是1。下图红色标注的输出序列都不合法：栈中合法的序列，双端队列中也一定合法。如果此时双端队列变为只能一端插入，两端删除时，栈中合法的序列在该双端队列中也一定合法，因此只需再验证栈中不合法的序列就可以得知哪些序列在该双端队列合法：比如4，3，2，1就不合法，因为4出去后，说明1，2，3已经进入，下一个出栈的要么是1(左边出
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值