划分树学习笔记——NOJ[1458] Teemo，POJ2761——Feed the dogs

最新推荐文章于 2023-04-08 10:38:52 发布
原创 最新推荐文章于 2023-04-08 10:38:52 发布 · 677 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了划分树的数据结构及其应用，重点在于如何使用划分树在对数时间内快速求出序列区间的第k大值。通过建树过程和查询方法的阐述，展示了划分树在解决特定问题上的高效性和实用性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这两个题都是划分树的模板题，下面来介绍下划分树，由于本人也是初次入门，如果有不对的地方，还请各位指正。

划分树是一种基于线段树的数据结构。主要用于快速求出(在log(n)的时间复杂度内）序列区间的第k大值 。
如图即一棵划分树：
     划分树学习笔记——NOJ[1458] Teemo，POJ2761——Feed the dogs - 深海灬孤独 - Alex
 

先来看下结构体： 
struct node
{
	int val[maxn];
	int num[maxn];
}tree[30];
树形结构都有层次之分，我们假设根为第0层。
上面的val数组是用来记录当前层的元素的，而num数组则是用来存当前位置以前的被划到左子树的元素个数。

接下来讲下建树过程
    划分树建树基于一个已排完序的数组，将比中值大的元素划到右子树，比中值小的元素划到左子树，如果有多个和中值一样大的元素，那么用一个变量isame=(mid-l+1)，先假设用这么多个和中值一样大的，然后for循环一遍，踢掉比中值小的，最后的isame就是要划到左子树的。其实isame原理是这样的，本来左子树就应该有mid-l+1个元素，减去那些比中值小的(即本来就要划到左子树的)，那么此时isame就是左子树还需要的元素个数，那么就从中值元素中去isame个来放到左边，其他的放到右边。
具体看下面代码： 
void build(int ind,int l,int r)
{
	if(l == r)//到叶子
	  return ;
    int mid=(l+r)>>1;
    int isame=mid-l+1,same=0;
    for(int i=l;i<=r;i++)
      if(sorted[mid] > tree[ind].val[i])
        isame--;//排除比中值小的
    int ln=l;//划分给下一层左子树的，开始位置
    int rn=mid+1;//划分给下一层右子树的，开始位置
    for(int i=l;i<=r;i++)
    {
    	if(l == i)//第一个元素之前没有被划到左子树的,所以初始化为0
    	{
	    	tree[ind].num[i]=0;
	    }
	    else
	    {
    		tree[ind].num[i]=tree[ind].num[i-1];
    	}
    	if(tree[ind].val[i] > sorted[mid])//如果大于中值，划到右边
    	{
	    	tree[ind+1].val[rn++]=tree[ind].val[i];
	    }
	    else if(tree[ind].val[i] < sorted[mid])//小于中值，分给左边
	    {
    		tree[ind+1].val[ln++]=tree[ind].val[i];
    		tree[ind].num[i]++;
    	}
    	else//和中值一样大
    	{
	    	if(isame >same)//还要划到左边
	    	{
	    		same++;
	    		tree[ind+1].val[ln++]=tree[ind].val[i];
	    		tree[ind].num[i]++;
	    	}
	    	else//划给右边
	    	{
	    		tree[ind+1].val[rn++]=tree[ind].val[i];
	    	}
	    }
    }
    build(ind+1,l,mid);//递归左右子树
    build(ind+1,mid+1,r);
}
建树小结：
    小的给左边，大的给右边，一样的话，根据isame来决定多少个中值放左边，多少个放右边。还有就是记得维护num，这个数组在查询时起到很大的作用。

接着是查询
     一般是给定一个区间[a,b]，问你其中第k大的元素是什么，这是就要靠num数组了。我们假设此时子树的区间是[l,r] ,我们用一个s0变量保存区间[l,a-1]之间被划到左边的元素的个数，用s1保存区间[a,b]之间被划到左边的元素个数。那么递归左右子树的条件又是什么？这个容易，判断k和s1的大小，如果s1>=k，那么递归左子树，否则递归右子树(如果不懂的话，可以这么想，要查的区间里被划到左边的个数超过了k个，而左边的数大小一定小于等于右边的，所以第k大元素一定被包含在左子树，否则就在右子树)。递归子树的问题是解决了，那么新的查询区间怎么办呢？先来看递归左子树时的情况，这里就要用到s0，s1了，s0是区间 [l,a-1]里被划到左边的元素个数，那么他一定在左子树的最左边，而我们要查的第k大元素绝不可能是这s0个元素里的，换句话说，这s0个元素不是在区间[a,b]里的，但又被划到了左子树，所以，新的查询区间的左极限可以是l+s0，即第k大元素至少在区间向右移动s0个单位上。那么右边极限怎么办？ [a,b]里有s1个被划到左子树的，此时第k大元素定在这s1个元素中产生，所以右极限就是l+s0+s1-1。这之后的元素一定不要，所以区间就可以卡在这里。 
if(s1 >= k)
    {
    	a=l+s0;
    	b=l+s0+s1-1;
    	return query(ind+1,l,mid,a,b,k);
    }
   再来看递归到右子树的情况，这个时候要注意递归查的不再是第k大了，而是第k-s1大元素，因为前s1大元素都在左子树了。同样也是递归区间的问题，还是要用到s0和s1，a-l-s0表示区间[l,a-1]里被划到右边的元素，b-a-1-s1表示区[a,b]里被划到右边的元素（减1是为了处理边界问题），右子树的开始位置是mid+1，同上，所以第k-s1大元素至少是从mid+1+a-l-s0开始的，至多在位置mid-l+1+b-s0-s1，至此，递归区间已分析完成。 
else
    {
    	a=mid-l+1+a-s0;
    	b=mid-l+1+b-s0-s1;
    	return query(ind+1,mid+1,r,a,b,k-s1);
    }

下面的是POJ2761和NOJ1458的题解。 
#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>

using namespace std;

const int maxn=100011;

int sorted[maxn];

struct node
{
	int val[maxn];
	int num[maxn];
}tree[30];

void build(int ind,int l,int r)
{
	if(l == r)
	  return ;
    int mid=(l+r)>>1;
    int isame=mid-l+1,same=0;
    for(int i=l;i<=r;i++)
      if(sorted[mid] > tree[ind].val[i])
        isame--;
    int ln=l;
    int rn=mid+1;
    for(int i=l;i<=r;i++)
    {
    	if(l == i)
    	{
	    	tree[ind].num[i]=0;
	    }
	    else
	    {
    		tree[ind].num[i]=tree[ind].num[i-1];
    	}
    	if(tree[ind].val[i] > sorted[mid])
    	{
	    	tree[ind+1].val[rn++]=tree[ind].val[i];
	    }
	    else if(tree[ind].val[i] < sorted[mid])
	    {
    		tree[ind+1].val[ln++]=tree[ind].val[i];
    		tree[ind].num[i]++;
    	}
    	else
    	{
	    	if(isame >same)
	    	{
	    		same++;
	    		tree[ind+1].val[ln++]=tree[ind].val[i];
	    		tree[ind].num[i]++;
	    	}
	    	else
	    	{
	    		tree[ind+1].val[rn++]=tree[ind].val[i];
	    	}
	    }
    }
    build(ind+1,l,mid);
    build(ind+1,mid+1,r);
}

int query(int ind,int l,int r,int a,int b,int k)//在区间[a,b]里找第k大，现在在区间[l,r] 
{
	if(a == b)
	  return tree[ind].val[a];
    int s0,s1,mid=(l+r)>>1;
    if(a == l)
    {
    	s0=0;
    	s1=tree[ind].num[b];
    }
    else
    {
    	s0=tree[ind].num[a-1];
    	s1=tree[ind].num[b]-s0;
    }
    if(s1 >= k)
    {
    	a=l+s0;
    	b=l+s0+s1-1;
    	return query(ind+1,l,mid,a,b,k);
    }
    else
    {
    	a=mid-l+1+a-s0;
    	b=mid-l+1+b-s0-s1;
    	return query(ind+1,mid+1,r,a,b,k-s1);
    }
}

int main()
{
	int n,m;
	while(~scanf("%d%d",&n,&m))
	{
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&tree[0].val[i]);
			sorted[i]=tree[0].val[i];
		}
		sort(sorted+1,sorted+n+1);
		build(0,1,n);
		int x,y,k;
		for(int i=0;i<m;i++)
		{
			scanf("%d%d%d",&x,&y,&k);
			printf("%d\n",query(0,1,n,x,y,k));
		}
	}
	return 0;
}

数据结构NOJ——24二叉排序树的判别
m0_56046092的博客
09-11 214
#include<iostream> using namespace std; #define MAX 20 typedef struct BiNode{ int data; struct BiNode* lchild, * rchild; }BiNode,*BiTree; //先序建立二叉树 void CreatTree(BiTree& T) { int ch; cin >> ch; if (ch == -1) T = NULL; else { if(!.
hdu5172---GTY's gay friends
Alex
02-14 1769
Problem Description GTY has n gay friends. To manage them conveniently, every morning he ordered all his gay friends to stand in a line. Every gay friend has a characteristic value ai , to express how
ACM学习历程——NOJ1113 Game I（贪心 || 线段树）
weixin_30907523的博客
04-28 89
Description 尼克发明了这样一个游戏：在一个坐标轴上，有一些圆，这些圆的圆心都在x轴上，现在给定一个x轴上的点，保证该点没有在这些圆内(以及圆上)，尼克可以以这个点为圆心做任意大小的圆，他想知道自己做多可以与多少个给定的圆相交(相切也算,包含不算)。 Input 输入有多组数据 输入到文件尾 每一组数据有一个整数n(1<=n<=100000)，表示总...
学习记录——顺序表（noj01-03）
2201_75741073的博客
04-08 103
step1. 类型定义step2.创建线性表+初始化——元素设置默认值，长度设置为0type2：可变长。
NOJ数据结构024——二叉排序树的判别
weixin_53068269的博客
06-07 804
#include<stdio.h> #include<stdlib.h> typedef struct BiTNode { int data; struct BiTNode* left; struct BiTNode* right; }BiTNode, * BiTree; BiTree CreateBiTree(); //创建二叉树 int JudgeBinary(BiTree T); //判断是否是二叉排序树 int main() { BiTree T; T
NOJ数据结构025——二叉排序树的插入和删除
weixin_53068269的博客
06-07 770
代码如下： #include<stdio.h> #include<stdlib.h> typedef struct BiTNode { int data; struct BiTNode* left; struct BiTNode* right; }BiTNode, * BiTree; BiTree CreateBiTree(); //创建二叉树 int JudgeBinary(BiTree T); //判断是否是二叉排序树 int main() { BiTre.
NOJ数据结构026——二叉排序树的合并
weixin_53068269的博客
06-07 556
代码如下： #include<stdio.h> #include<stdlib.h> typedef struct BiTNode { int data; struct BiTNode* left; struct BiTNode* right; }BiTNode, * BiTree; BiTree CreateBiTree(); //创建二叉树 void InsertBi(BiTree* T, int insert);//插入节点 void CombineBi(BiT.
学习MSCKF笔记——后端、状态预测、状态扩增、状态更新
weixin_44580210的博客
09-05 3811
学习MSCKF笔记——后端、状态扩增学习MSCKF笔记——后端、状态扩增 学习MSCKF笔记——后端、状态扩增 为了看懂后端代码，我先看了下《Quaternion kinematics for the error-state Kalman filter》这篇参考文献，写了两篇总结文档 学习MSCKF笔记——四元数基础 学习MSCKF笔记——误差状态卡尔曼滤波 MSCKF的后端内容还是很多的，Stereo-MSCKF的代码也写得很好，通过读代码将MSCKF后端流程图总结如下: 下面我将后端中几个关键的知识点
php 编写 online judge,基于 Laravel 的开源 Online Judge 项目——NOJ
weixin_36155560的博客
03-29 290
NOJNOJ是一个由PHP+Laravel开发而成的开源在线测评系统，开源地址：GitHub Repo。InstallationCentOS will be recommended for hosting NOJ, but all major operating systems are theoretically supported.Till now, NOJ have been successf...
数据结构NOJ——23构造哈希表
m0_56046092的博客
09-11 242
#include<iostream> using namespace std; #define SIZE 11 #define NULLKEY 0 typedef struct { int key; int flag;//计算地址的次数 }RecordType,*HashTable; void HashSreach(HashTable ht,int data[]) { for (int i = 0; i <SIZE; i++) { ht[i].key = 0; ht.
hdu5141——LIS again
Alex
12-07 1716
LIS again Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 132    Accepted Submission(s): 34 Problem Description A numeric sequence of a
Codeforces Round #291 (Div. 2)---C. Watto and Mechanism
Alex
02-15 1562
Watto, the owner of a spare parts store, has recently got an order for the mechanism that can process strings in a certain way. Initially the memory of the mechanism is filled with n strings. Then the
hdu3607——Traversal
Alex
12-07 1219
Traversal Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 1038    Accepted Submission(s): 365 Problem Description Xiao Ming is travelli
POJ2029——Get Many Persimmon Trees
Alex
10-30 1204
Get Many Persimmon Trees Time Limit: 1000MS   Memory Limit: 30000K Total Submissions: 3656   Accepted: 2378 Description Seiji Hayashi had been a professor of the Nisshinkan
hdu2275——Kiki & Little Kiki 1
Alex
12-17 1197
Kiki & Little Kiki 1 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 873    Accepted Submission(s): 283 Problem Description Kiki is con
POJ2492---A Bug's Life
Alex
01-22 1193
A Bug's Life Time Limit: 10000MS   Memory Limit: 65536K Total Submissions: 29209   Accepted: 9528 Description Background Professor Hopper is researching the sexual behavio
Codeforces Round #170 (Div. 2)---C. Learning Languages(并查集)
Alex
04-03 1181
The “BerCorp” company has got n employees. These employees can use m approved official languages for the formal correspondence. The languages are numbered with integers from 1 to m. For each employee w
Codeforces Round #172 (Div. 2)---D. Maximum Xor Secondary（RMQ + 二分）
Alex
04-03 1142
Bike loves looking for the second maximum element in the sequence. The second maximum element in the sequence of distinct numbers x1, x2, …, xk (k > 1) is such maximum element xj, that the following in
sdut2610---Boring Counting(离线+树状数组+离散化)
Alex
04-06 1114
Boring Counting Time Limit: 3000ms Memory limit: 65536K 有疑问？点这里^_^ 题目描述 In this problem you are given a number sequence P consisting of N integer and Pi is the ith element in the sequence. No
西工大NOJ数据结构实验——3.1哈夫曼
05-24
哈夫曼编码是一种常用的数据压缩算法，可以将原始数据转换为更短的编码，从而减少存储空间。它的基本思想是：根据字符出现的频率，构建一颗二叉树，使得出现频率高的字符离根节点近，出现频率低的字符离根节点远。然后，对于每个字符，从根节点出发，沿着对应的路径到达该字符所在的叶子节点，记录下路径，作为该字符的编码。 哈夫曼编码的具体实现步骤如下： 1. 统计每个字符在原始数据中出现的频率。 2. 根据字符的频率构建哈夫曼树。构建方法可以采用贪心策略，每次选择出现频率最低的两个字符，将它们作为左右子节点，父节点的权值为两个子节点的权值之和。重复这个过程，直到只剩下一个根节点。 3. 对哈夫曼树进行遍历，记录下每个字符的编码，为了避免编码产生歧义，通常规定左子节点为0，右子节点为1。 4. 将原始数据中的每个字符，用它对应的编码来代替。这一步可以通过哈夫曼树来实现。 5. 将编码后的数据存储起来。此时，由于每个字符的编码长度不同，所以压缩后的数据长度也不同，但总体上来说，压缩效果通常是比较好的。 实现哈夫曼编码的关键在于构建哈夫曼树和计算每个字符的编码。构建哈夫曼树可以采用优先队列来实现，每次从队列中取出两个权值最小的节点，合并成一个节点，再将合并后的节点插入队列中。计算每个字符的编码可以采用递归遍历哈夫曼树的方式，从根节点出发，如果走到了左子节点，则将0添加到编码中，如果走到了右子节点，则将1添加到编码中，直到走到叶子节点为止。 以下是基于C++的代码实现，供参考： ```c++ #include <iostream> #include <queue> #include <string> #include <unordered_map> using namespace std; // 定义哈夫曼树节点的结构体 struct Node { char ch; // 字符 int freq; // 出现频率 Node* left; // 左子节点 Node* right; // 右子节点 Node(char c, int f) : ch(c), freq(f), left(nullptr), right(nullptr) {} }; // 定义哈夫曼树节点的比较函数，用于优先队列的排序 struct cmp { bool operator() (Node* a, Node* b) { return a->freq > b->freq; } }; // 构建哈夫曼树的函数 Node* buildHuffmanTree(unordered_map<char, int> freq) { priority_queue<Node*, vector<Node*>, cmp> pq; for (auto p : freq) { pq.push(new Node(p.first, p.second)); } while (pq.size() > 1) { Node* left = pq.top(); pq.pop(); Node* right = pq.top(); pq.pop(); Node* parent = new Node('$', left->freq + right->freq); parent->left = left; parent->right = right; pq.push(parent); } return pq.top(); } // 遍历哈夫曼树，计算每个字符的编码 void calcHuffmanCode(Node* root, unordered_map<char, string>& code, string cur) { if (!root) return; if (root->ch != '$') { code[root->ch] = cur; } calcHuffmanCode(root->left, code, cur + "0"); calcHuffmanCode(root->right, code, cur + "1"); } // 将原始数据编码成哈夫曼编码 string encode(string s, unordered_map<char, string> code) { string res; for (char c : s) { res += code[c]; } return res; } // 将哈夫曼编码解码成原始数据 string decode(string s, Node* root) { string res; Node* cur = root; for (char c : s) { if (c == '0') { cur = cur->left; } else { cur = cur->right; } if (!cur->left && !cur->right) { res += cur->ch; cur = root; } } return res; } int main() { string s = "abacabad"; unordered_map<char, int> freq; for (char c : s) { freq[c]++; } Node* root = buildHuffmanTree(freq); unordered_map<char, string> code; calcHuffmanCode(root, code, ""); string encoded = encode(s, code); string decoded = decode(encoded, root); cout << "Original string: " << s << endl; cout << "Encoded string: " << encoded << endl; cout << "Decoded string: " << decoded << endl; return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值