POJ 2761 Feed the dogs

最新推荐文章于 2019-10-17 17:44:37 发布
最新推荐文章于 2019-10-17 17:44:37 发布
阅读量553 收藏
点赞数
分类专栏： POJ ###### 数据结构 ####### ++++ 二叉树 ++++ - SBT 文章标签： SBT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013569656/article/details/20156717
版权

题目大意：

        Wind爱狗，并且有n条狗（n < 100,001），佳佳不爱狗，但是爱Wind，所以他每天需要替Wind喂狗。当然了，他自有特别的喂狗方式，每到中饭时间够就会按照编号站成一排，从左到有一次为1, 2, 3...n号，每条狗都会被佳佳赋予一个“可爱值”，可爱值互不相同，喂的时候佳佳会先选出一个编号区间[i号-j号]，然后在该区间中选择“可爱值”第k大的狗喂食，这样可以避免多次喂同样几条狗导致狗被喂死（这会让Wind大发雷霆，后果很严重）。

        喂食会有m次（m < 50,001），每次都会指定选择区间（i, j）和k（区间内“可爱值”第k大的狗），先求出每次被喂食的狗的“可爱值”，选中的区间可能会相互重叠，只有一个测例。

题目链接

使用规模平衡二叉树SBT（Size Balanced Tree）：

注释代码：

/*               
 * Problem ID : POJ 2761 Feed the dogs
 * Author     : Lirx.t.Una               
 * Language   : C++       
 * Run Time   : 2032 ms               
 * Run Memory : 3248 KB               
*/    

#include <stdlib.h>
#include <stdio.h>

//表示树的结点为空
#define	NILL	0

#define	TRUE	1
#define	FALSE	0

//maximum number of dogs
//狗的最大数量
#define	MAXDOGN		100001
//maximum number of feedings
//喂食的最大次数
#define	MAXFEEDN	50001



struct	BFeeding {//Feeding body，
	//关于喂食的结构体

	int		l;//left，喂食的区间左端
	int		r;//right，喂食的区间右端
	int		k;//选择可爱值第k大的狗进行喂食
	int		ord;//ordinal，指明本次是第几次喂食
};

typedef struct BFeeding		Feeding;
typedef	struct BFeeding *	Feed;
typedef	struct BFeeding **	PtFeed;

typedef	int		BOOL;
typedef	int		Tree;//使用数组实现SBT

Feeding		bf[MAXFEEDN];
Feed		f[MAXFEEDN];
int			ans[MAXFEEDN];//存放每次喂食的答案
                  //即每次第k大的狗的可爱值

//以下四项为SBT树中的结点
//其中树结点i中包含了四个域
//key[i]可爱值
//siz[i]即size，即该棵树的大小（总共包含几个结点）
//lft[i]、rht[i]，该结点的左右子树
int			key[MAXDOGN] = { 0 };
int			siz[MAXDOGN] = { 0 };
Tree		lft[MAXDOGN] = { NILL };
Tree		rht[MAXDOGN] = { NILL };

int			dog[MAXDOGN];//dog[i]表示第i条狗的可爱值

Tree
RotL(Tree k2) {//AVL左旋

	Tree k1;

	k1		= lft[k2];
	lft[k2]	= rht[k1];
	rht[k1]	= k2;

	siz[k1]	= siz[k2];
	siz[k2] = siz[ lft[k2] ] + siz[ rht[k2] ] + 1;

	return k1;
}

Tree
RotR(Tree k2) {//AVL右旋

	Tree k1;

	k1		= rht[k2];
	rht[k2] = lft[k1];
	lft[k1]	= k2;

	siz[k1]	= siz[k2];
	siz[k2]	= siz[ lft[k2] ] + siz[ rht[k2] ] + 1;

	return k1;
}

Tree
RotLR(Tree t) {//AVL左右双旋

	rht[t] = RotL( rht[t] );

	return RotR(t);
}

Tree
RotRL(Tree t) {//AVL右左双旋

	lft[t] = RotR( lft[t] );

	return RotL(t);
}

Tree
Maintain( Tree tree, BOOL cmp ) {//维护
	//SBT的插入其实都是普通的BST插入，在每次
	//插入后都会使用该函数对SBT树进行维护
	//以调整它的高度，使之平衡

	if ( cmp )//表示插入的可爱值k小于tree结点的可爱值
		//此时该结点必定插入到了tree的左子树，因此需要
		//检查左子树是否过大

		if ( siz[ lft[ lft[tree] ] ] > siz[ rht[tree] ] )
			tree = RotL(tree);//若左子树的左子树规模大于右子树则需左旋
		else
			if ( siz[ rht[ lft[tree] ] ] > siz[ rht[tree] ] )
				tree = RotRL(tree);//若左子树的右子树规模大于右子树则需右左旋
			else
				return tree;//否则就表示满足平衡条件，可以直接退出函数
	else//对于插入到右子树的情形也是相同的
		if ( siz[ rht[ rht[tree] ] ] > siz[ lft[tree] ] )
			tree = RotR(tree);
		else
			if ( siz[ lft[ rht[tree] ] ] > siz[ lft[tree] ] )
				tree = RotLR(tree);
			else
				return tree;

	//即使旋转过也并不代表概述一定就满足平衡条件了，需要继续探测并调整


	//当旋转后左右子仍存在的，则继续向树的最外两侧探测和调整
	if ( lft[tree] )
		lft[tree] = Maintain( lft[tree], TRUE );

	if ( rht[tree] )
		rht[tree] = Maintain( rht[tree], FALSE );

	//此时左右子树已经完美平衡了，但顶点本身可能离平衡只有微小的距离
	//因此此次维护只是做一点点微调，不会耗多少时间的
	tree = Maintain( tree, TRUE );//左微调一次

	return Maintain( tree, FALSE );//最后再右微调一次
}

Tree
Insert( Tree tree, int node, int k ) {

	if ( !tree ) {
	
		key[node] = k;
		siz[node] = 1;

		lft[node] = NILL;
		rht[node] = NILL;

		return node;
	}

	siz[tree]++;

	if ( k < key[tree] )
		lft[tree] = Insert( lft[tree], node, k );
	else
		rht[tree] = Insert( rht[tree], node, k );

	//到这之前都是很平常的BST插入
	return Maintain( tree, k < key[tree] );
}

Tree
Remove( Tree tree, int k ) {

	if ( !tree )
		return NILL;

	siz[tree]--;//由于题目的限制，每次删除的结点
	     //必定都在树中，因此不需要再写Find函数判断
	     //待删的结点是否在树中了，因此可以直接--

	if ( k == key[tree] ) {//若当前结点就是待删结点
	
		if ( !lft[tree] || !rht[tree] )//对于左右子树有空的
			return lft[tree] + rht[tree];//直接返回非空的
		                  //或者两者都是空的，则就直接删除即可

		int node;

		//若左右子树都非空，则可以将左子树中最大的结点
		  //即右下角的结点作为根结点（树顶）代替老的树顶
		  //然后再删除该结点就行了

		//先找到该结点（由于它是左子树中最大的结点，因此可以作为新树顶）
		node = lft[tree];
		while ( rht[node] )
			node = rht[node];

		key[tree] = key[node];//替代
		lft[tree] = Remove( lft[tree], key[node] );//再删除该结点

		return tree;
	}

	if ( k < key[tree] )
		lft[tree] = Remove( lft[tree], k );
	else
		rht[tree] = Remove( rht[tree], k );

	return tree;
}

int
Rank( Tree tree, int k ) {//按照可爱值大小排名

	int		mid;

	mid = siz[ lft[tree] ] + 1;//树顶是第mid大的

	if ( k == mid )
		return key[tree];

	if ( k < mid )
		return Rank( lft[tree], k );
	else
		return Rank( rht[tree], k - mid );
}

int
fcmp(const void *a, const void *b) {

	Feed	fa, fb;

	fa = *(PtFeed)a;
	fb = *(PtFeed)b;

	//排序时按照喂食区间的左端从小到大排
	if ( fa->l - fb->l )
		return fa->l - fb->l;
	else//若左端相等则按照右端从小到大排
		return fa->r - fb->r;
}

int
main() {

	int		n, m;//狗总数和喂食总次数
	int		i, j;//计数变量
	int		l, r;//先区间left - right
	int		pl, pr;//上衣区间previous left - previous right

	int		node;//插入的结点号
	Tree	tree;//SBT树

	scanf("%d%d", &n, &m);
	for ( i = 1; i <= n; i++ )	
		scanf("%d", dog + i);
	for ( i = 1; i <= m; i++ ) {
	
		scanf("%d%d%d", &bf[i].l, &bf[i].r, &bf[i].k);
		bf[i].ord = i;
		f[i]	  = bf + i;//利用指针数组对原数组排序，省时间
	}
	//具体做法是对于每个区间，都构建一个该区间的SBT树
	//然后对该数求rank，即可得到第k大的狗了
	//但是为了避免重复构建相同区间的SBT（或者是重合的）
	//对喂食进行排序（左端从小到大，若相同则右端从小到大）
	  //可以避免对重叠的区间重复构造SBT树
	qsort(f + 1, m, sizeof(Feed), &fcmp);

	//初始化
	tree = NILL;
	node = 0;
	pl	 = 1;
	pr	 = 0;

	for ( i = 1; i <= m; i++ ) {
	
		l = f[i]->l;
		r = f[i]->r;

		//×表示该区间需要删除
		//*表示该区间需要构建
		//空表示该区间什么都不用做
		//不变表示该区间保留，无需删除和构建
		if ( l > pr ) {// pl×××pr  空  l****r
		
			for ( j = pl; j <= pr; j++ )
				tree = Remove( tree, dog[j] );
			for ( j = l; j <= r; j++ )
				tree = Insert( tree, ++node, dog[j] );
		}
		else
			if ( r > pr ) {// pl×××l 不变 pr****r
			
				for ( j = pl; j < l; j++ )
					tree = Remove( tree, dog[j] );
				for ( j = pr + 1; j <= r; j++ )
					tree = Insert( tree, ++node, dog[j] );
			}
			else {// pl×××l 不变 r×××pr
			
				for ( j = pl; j < l; j++ )
					tree = Remove( tree, dog[j] );
				for ( j = pr + 1; j < r; j++ )
					tree = Remove( tree, dog[j] );
			}

		pl = l;
		pr = r;

		ans[ f[i]->ord ] = Rank( tree, f[i]->k );
	}

	for ( i = 1; i <= m; i++ )
		printf("%d\n", ans[i]);

	return 0;
}

无注释代码：

#include <stdlib.h>
#include <stdio.h>

#define	NILL	0
#define	TRUE	1
#define	FALSE	0

#define	MAXDOGN		100001
#define	MAXFEEDN	50001

struct	BFeeding {

	int		l;
	int		r;
	int		k;
	int		ord;
};

typedef struct BFeeding		Feeding;
typedef	struct BFeeding *	Feed;
typedef	struct BFeeding **	PtFeed;

typedef	int		BOOL;
typedef	int		Tree;

Feeding		bf[MAXFEEDN];
Feed		f[MAXFEEDN];
int			ans[MAXFEEDN];

int			key[MAXDOGN] = { 0 };
int			siz[MAXDOGN] = { 0 };
Tree		lft[MAXDOGN] = { NILL };
Tree		rht[MAXDOGN] = { NILL };

int			dog[MAXDOGN];

Tree
RotL(Tree k2) {

	Tree k1;

	k1		= lft[k2];
	lft[k2]	= rht[k1];
	rht[k1]	= k2;

	siz[k1]	= siz[k2];
	siz[k2] = siz[ lft[k2] ] + siz[ rht[k2] ] + 1;

	return k1;
}

Tree
RotR(Tree k2) {

	Tree k1;

	k1		= rht[k2];
	rht[k2] = lft[k1];
	lft[k1]	= k2;

	siz[k1]	= siz[k2];
	siz[k2]	= siz[ lft[k2] ] + siz[ rht[k2] ] + 1;

	return k1;
}

Tree
RotLR(Tree t) {

	rht[t] = RotL( rht[t] );

	return RotR(t);
}

Tree
RotRL(Tree t) {

	lft[t] = RotR( lft[t] );

	return RotL(t);
}

Tree
Maintain( Tree tree, BOOL cmp ) {

	if ( cmp )
		if ( siz[ lft[ lft[tree] ] ] > siz[ rht[tree] ] )
			tree = RotL(tree);
		else
			if ( siz[ rht[ lft[tree] ] ] > siz[ rht[tree] ] )
				tree = RotRL(tree);
			else
				return tree;
	else
		if ( siz[ rht[ rht[tree] ] ] > siz[ lft[tree] ] )
			tree = RotR(tree);
		else
			if ( siz[ lft[ rht[tree] ] ] > siz[ lft[tree] ] )
				tree = RotLR(tree);
			else
				return tree;

	if ( lft[tree] )
		lft[tree] = Maintain( lft[tree], TRUE );

	if ( rht[tree] )
		rht[tree] = Maintain( rht[tree], FALSE );

	tree = Maintain( tree, TRUE );

	return Maintain( tree, FALSE );
}

Tree
Insert( Tree tree, int node, int k ) {

	if ( !tree ) {
	
		key[node] = k;
		siz[node] = 1;

		lft[node] = NILL;
		rht[node] = NILL;

		return node;
	}

	siz[tree]++;

	if ( k < key[tree] )
		lft[tree] = Insert( lft[tree], node, k );
	else
		rht[tree] = Insert( rht[tree], node, k );

	return Maintain( tree, k < key[tree] );
}

BOOL
Find( Tree tree, int k ) {

	if ( !tree )
		return FALSE;

	if ( k == key[tree] )
		return TRUE;

	if ( k < key[tree] )
		return Find( lft[tree], k );
	else
		return Find( rht[tree], k );
}

Tree
Remove( Tree tree, int k ) {

	if ( !tree )
		return NILL;

	siz[tree]--;

	if ( k == key[tree] ) {
	
		if ( !lft[tree] || !rht[tree] )
			return lft[tree] + rht[tree];

		int node;

		node = lft[tree];
		while ( rht[node] )
			node = rht[node];

		key[tree] = key[node];
		lft[tree] = Remove( lft[tree], key[node] );

		return tree;
	}

	if ( k < key[tree] )
		lft[tree] = Remove( lft[tree], k );
	else
		rht[tree] = Remove( rht[tree], k );

	return tree;
}

int
Rank( Tree tree, int k ) {

	int		mid;

	mid = siz[ lft[tree] ] + 1;

	if ( k == mid )
		return key[tree];

	if ( k < mid )
		return Rank( lft[tree], k );
	else
		return Rank( rht[tree], k - mid );
}

int
fcmp(const void *a, const void *b) {

	Feed	fa, fb;

	fa = *(PtFeed)a;
	fb = *(PtFeed)b;

	if ( fa->l - fb->l )
		return fa->l - fb->l;
	else
		return fa->r - fb->r;
}

int
main() {

	int		n, m;
	int		i, j;
	int		l, r;
	int		pl, pr;

	int		node;
	Tree	tree;

	scanf("%d%d", &n, &m);
	for ( i = 1; i <= n; i++ )	
		scanf("%d", dog + i);
	for ( i = 1; i <= m; i++ ) {
	
		scanf("%d%d%d", &bf[i].l, &bf[i].r, &bf[i].k);
		bf[i].ord = i;
		f[i]	  = bf + i;
	}
	qsort(f + 1, m, sizeof(Feed), &fcmp);

	tree = NILL;
	node = 0;
	pl	 = 1;
	pr	 = 0;

	for ( i = 1; i <= m; i++ ) {
	
		l = f[i]->l;
		r = f[i]->r;

		if ( l > pr ) {
		
			for ( j = pl; j <= pr; j++ )
				tree = Remove( tree, dog[j] );
			for ( j = l; j <= r; j++ )
				tree = Insert( tree, ++node, dog[j] );
		}
		else
			if ( r > pr ) {
			
				for ( j = pl; j < l; j++ )
					tree = Remove( tree, dog[j] );
				for ( j = pr + 1; j <= r; j++ )
					tree = Insert( tree, ++node, dog[j] );
			}
			else {
			
				for ( j = pl; j < l; j++ )
					tree = Remove( tree, dog[j] );
				for ( j = pr + 1; j < r; j++ )
					tree = Remove( tree, dog[j] );
			}

		pl = l;
		pr = r;

		ans[ f[i]->ord ] = Rank( tree, f[i]->k );
	}

	for ( i = 1; i <= m; i++ )
		printf("%d\n", ans[i]);

	return 0;
}

单词解释：

pretty：adj, 漂亮的，可爱的

lunchtime：n, 午饭时间

leftmost/rightmost：adj, 最左边的/左右边的

afterefftect：n, 后果

hence：adj, 因此

intersect with：和...相交

__Lirx_t_Una__
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
POJ1027-The Same Game
07-31
北大POJ1027-The Same Game 解题报告+AC代码
POJ 2761 Feed the dogs （SBT+离线处理询问）
Paradiser
08-23 941
给定n个数，m次询问，n个数为1--n的排列，每次询问给出了一个区间和k，询问在区间内为第k小的数。 区间内第k小（大）的数可以用SBT来解决，现在m次询问则是动态的，可以用离线处理：将询问区间排序，每次需要插入则插入，需要删除则删除，节省很多时间....... #include #include #include #include #include #include
poj2761 Feed the dogs
AaronPolaris
11-21 1636
Treap模板题
POJ2761 Feed the dogs
dezhen7015的博客
10-04 72
Time Limit:6000MS Memory Limit:65536KB 64bit IO Format:%lld & %llu Description Wind loves pretty dogs very much, and she has n pet dogs. So Jiajia has t...
poj 2761 Feed the dogs
ba1_1ad的博客
08-14 367
题意：给出n( 解：因为两两查询区间互不包含，所以按L从小到大排序，则必有Li       所以对于每一个查询，删除当前treap中当前查询不包含的点，插入当前treap中当前查询未插入的点       每个点删，插各一次，用treap实现，所以时间复杂度为O(nlogn) 代码： #include #include #include #include #include #d
POJ2761 Feed the dogs（Treap）
邵光亮的博客
10-17 185
Description Wind loves pretty dogs very much, and she has n pet dogs. So Jiajia has to feed the dogs every day for Wind. Jiajia loves Wind, but not the dogs, so Jiajia use a special way to feed the ...
北大POJ1163-The Triangle
05-11
北大POJ1163-The Triangle
POJ1163-The Triangle
07-31
北大POJ1163-The Triangle 解题报告+AC代码
POJ2635-The Embarrassed Cryptographer
07-31
北大POJ2635-The Embarrassed Cryptographer 解题报告+AC代码
POJ3267-The Cow Lexicon
07-31
北大POJ3267-The Cow Lexicon 解题报告+AC代码
POJ 2259 Team Queue
源代码
02-24 1259
题目大意：          队列和优先队列在计算机科学界耳熟能详，但组队列并没那么有名，但它经常出现在日常生活中，比如在餐厅里面排队买饭的队列就是。          在一个组队列中，每个元素都属于某一组，在入队时会先找熟人（即同组组员），若有则直接插到同组人的末尾（相当于队列中的队列），若无则只能排到整个队列的末尾了同时他将成为他所属的组中第一个出现在组队列中的成员。对于出队列，就和普通的
POJ 3481 Double Queue
源代码
02-27 986
题目大意： 伸展树： 注释代码： 无注释代码： STL： 注释代码： 无注释代码： 树堆： 注释代码： 无注释代码： 单词解释：
POJ 2051 Argus
源代码
02-24 867
题目大意： 单词解释： Argus：人名，希腊神话中的百眼巨人 stream：n, 流，溪流 real-time：adj, 实时的，接到指示立即执行的 continuous：adj, 连续不断的 ordered：adj, 有序的 item：n, 项目，条款，物件 sensor：n, 传感器 traffic：n, 交通，通信量 Internet traffic：n, 英特网通信量
POJ 2559 Largest Rectangle in a Histogram
源代码
02-24 827
题目大意：         在一张直方图（每天柱子的宽都是1）中找出最大面积矩形并输出其面积。         有多个测例，每个测例都会给出该测例中唯一一个直方图中柱子的数量n（n ≤ 100,000），并依次（按照直方图中从左往右的顺序）给出每根柱子的高度hi（hi ≤ 1,000,000,000），对于每个测例都需要输出最大矩形的面积，以n等于0结束测例退出程序。         ！！！
ZOJ 2334 Monkey King
源代码
03-01 817
题目大意： 注释代码： 无注释代码： 单词解释： aggressive：adj, 侵略性的，好斗的 quarrel：vt, 吵架，争论 duel：vi/n, 决斗 conflict：vt/n, 冲突，争斗 reduce：vt, 减少
POJ 2418 Hardwood Species
源代码
02-27 718
题目大意： BST： 注释代码： 无注释代码： AVL： 注释代码： 无注释代码： 单词解释： hardwood：n, 阔叶树，硬木 hardwoods：n, 阔叶林
POJ 2082 Terrible Sets
源代码
02-24 656
题目大意：         若干矩形相互紧挨着在一条轴线上排成一排，求这些矩形所覆盖的区域中面积最大的矩形，输出其面积。         ！！！和POJ 2559类同（只不过其每个矩形的底边长都是1）。         其中，矩形数不超过50000，所有矩形面积之和不超过10^9，多个测例（题中给出数目），以矩形个数为-1结束测例退出程序。 注释代码： /* * Probl
POJ 3832 Posters
源代码
06-02 641
题目大意： 题目链接 注释代码： 无注释代码： dan
POJ 2785 4 Values whose Sum is 0
源代码
03-21 606
题目大意： 开放地址Hash： 注释代码： 无注释代码： 二分搜索： 注释代码： 无注释代码： 单词解释：
poj Divisibility
最新发布
09-12
POJ Divisibility是一个编程题，要求编写一个程序来确定一系列整数是否可被K整除。输入文件的第一行包含两个整数N和K，用一个空格分隔。第二行包含一系列N个整数，以空格分隔。每个整数的绝对值不大于10000。在输出...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值