K-th Number
Time Limit: 20000MS   Memory Limit: 65536K
Total Submissions: 50247   Accepted: 17101
Case Time Limit: 2000MS

Description

You are working for Macrohard company in data structures department. After failing your previous task about key insertion you were asked to write a new data structure that would be able to return quickly k-th order statistics in the array segment. 
That is, given an array a[1...n] of different integer numbers, your program must answer a series of questions Q(i, j, k) in the form: "What would be the k-th number in a[i...j] segment, if this segment was sorted?" 
For example, consider the array a = (1, 5, 2, 6, 3, 7, 4). Let the question be Q(2, 5, 3). The segment a[2...5] is (5, 2, 6, 3). If we sort this segment, we get (2, 3, 5, 6), the third number is 5, and therefore the answer to the question is 5.

Input

The first line of the input file contains n --- the size of the array, and m --- the number of questions to answer (1 <= n <= 100 000, 1 <= m <= 5 000). 
The second line contains n different integer numbers not exceeding 109 by their absolute values --- the array for which the answers should be given. 
The following m lines contain question descriptions, each description consists of three numbers: i, j, and k (1 <= i <= j <= n, 1 <= k <= j - i + 1) and represents the question Q(i, j, k).

Output

For each question output the answer to it --- the k-th number in sorted a[i...j] segment.

Sample Input

7 3
1 5 2 6 3 7 4
2 5 3
4 4 1
1 7 3

Sample Output

5
6
3

Hint

This problem has huge input,so please use c-style input(scanf,printf),or you may got time limit exceed.

题目链接:POJ 2104    HDU 2665(HDU题面描述有误,虽说是求kth big其实还是跟POJ一样求kth small)

看主席树看了N久,终于把更新操作和查询操作看懂了:),其间找了无数篇博客但是其中绝大部分都是泛泛而谈有一些甚至只有代码连注释都没有,

很多次想弃疗(感觉这高大上的数据结构弱比我估计以后很难用到),然而还是没有放弃终于看懂一点点……故想通过这两道模版题来说一下弱比我的理解……

首先要知道普通线段树如何求整个范围内第k大,单点更新+单点查询(至叶子节点),然后就是这个区间第K大(小)怎么弄呢?由于单点更新的时候只会更新一条路上的东西即树上一层只会更新一个节点,比如某一层有两个节点来管理【1,2】与【 3,4】,假设更新1这个值,显然【3,4】是不会变的,只是管理【1,2】这个节点的cnt值加1,当然,这个节点下面还有【1,1】与【2,2】这俩叶子,同样道理也只会更新管理【1,1】的节点,使它的cnt值加1,管理【2,2】的节点不动……

根据二叉树的性质可以知道,每一次修改就只要新建出Log(N)左右个节点就可以与之前的树形成一个新的树,树上的老节点就是不用更新的,新节点就是更新的再指向老的节点(即很可能会与老节点共用子节点)。然后就用到了前缀和的思想,一个元素均不相同的序列可以发现这样一个规律,假设10个数为1 3 5 7 9 2 4 6 8 10,先简化一下问题,求【3,7】的节点cnt为多少,那显然是【1,7】.cnt-【1,(3-1)】.cnt=5,继而就可以求【3,4】、【5,7】甚至更后面的小区间内cnt值,那问题就成了一个前面讲的线段树求整个范围内第k大,只是整个范围一直被维护为L,R之间而已。

主席树这种写法需要root数组、和lson与rson的数组,还有记录区间内数字出现个数的cnt数组

更新操作:首先复制当前所在原节点的所有信息,再将cnt+1(因为你在原来的基础上插入了一个数),然后用单点更新的思路进行复制并更新(讲复制感觉更贴切实际,因为更新是在副本上更新的而不是原来节点上),走到哪就把哪个节点复制下来再在这个副本上进行更新

查询操作:用两颗不同的树的cnt作差再判断查询方向,写法上跟普通的单点查询非常相似

最后题目数据范围比较大需要离散化一下另外我加了个没什么卵用的读入外挂……

POJ 2104代码:

#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define CLR(x,y) memset(x,y,sizeof(x))
#define LC(x) (x<<1)
#define RC(x) ((x<<1)+1)
#define MID(x,y) ((x+y)>>1)
typedef pair<int,int> pii;
typedef long long LL;
const int N=100010;
struct seg
{
int lson,rson;
int cnt;
};
seg T[N*20];
int tot,rt[N];
int arr[N];
vector<int>pos;
void init()
{
tot=0;
CLR(rt,0);
pos.clear();
}
int Scan()
{
int res=0,ch,flag=0;
if((ch=getchar())=='-')
flag=1;
else if(ch>='0'&&ch<='9')
res=ch-'0';
while((ch=getchar())>='0'&&ch<='9')
res=res*10+ch-'0';
return flag?-res:res;
}
void build(int &cur,int l,int r)//注意第一个参数是引用为了修改原值
{
cur=++tot;
T[cur].cnt=0;
if(l==r)
return ;
else
{
int mid=MID(l,r);
build(T[cur].lson,l,mid);
build(T[cur].rson,mid+1,r);
}
}
void update(int &cur,int ori,int l,int r,int val)//cur为准备新开的节点,ori为原来对应位置的节点
{
cur=++tot;//新建一颗树
T[cur].lson=T[ori].lson;//复制信息
T[cur].rson=T[ori].rson;//复制信息
T[cur].cnt=T[ori].cnt+1;//更新新增值
if(l==r)
return ;
else
{
int mid=MID(l,r);
if(val<=mid)
update(T[cur].lson,T[ori].lson,l,mid,val);
else
update(T[cur].rson,T[ori].rson,mid+1,r,val);
}
}
int query(int st,int ed,int l,int r,int k)
{
if(l==r)
return l;
else
{
int mid=MID(l,r);
int cnt=T[T[ed].lson ].cnt-T[T[st].lson ].cnt;//与普通求Kth一样先看lson(看rson也行下面顺序变一下而已)
if(k<=cnt)
return query(T[st].lson,T[ed].lson,l,mid,k);
else
return query(T[st].rson,T[ed].rson,mid+1,r,k-cnt);
}
}
int main(void)
{
int n,m,i,l,r,k;
while (~scanf("%d%d",&n,&m))
{
for (i=1; i<=n; ++i)
{
scanf("%d",&arr[i]);
pos.push_back(arr[i]);
} sort(pos.begin(),pos.end());//pos储存着原值
pos.erase(unique(pos.begin(),pos.end()),pos.end());
for (i=1; i<=n; ++i)
arr[i]=lower_bound(pos.begin(),pos.end(),arr[i])-pos.begin()+1;//arr变为离散化之后的数组仅用来更新 int SZ=pos.size();
build(rt[0],1,SZ); for (i=1; i<=n; ++i)
update(rt[i],rt[i-1],1,SZ,arr[i]);
for (i=0; i<m; ++i)
{
l=Scan();
r=Scan();
k=Scan();
int indx=query(rt[l-1],rt[r],1,SZ,k)-1;//由于pos下标从0开始
printf("%d\n",pos[indx]);//再映射回去
}
init();
}
return 0;
}

搞半天发现build没什么卵用……直接update也行,离散化也优化了一下,简化了HDU的代码,速度快了不少

HDU代码:

#include <stdio.h>
#include <algorithm>
#include <vector>
#include <string.h>
using namespace std;
#define CLR(arr,val) memset(arr,val,sizeof(arr))
#define MID(x,y) ((x+y)>>1) const int N=1e5+7;
struct seg
{
int lson,rson;
int cnt;
};
seg T[N*20];
int tot,root[N];
int arr[N];
vector<int>vec; void init()
{
tot=0;
vec.clear();
CLR(root,0);
}
void update(int &cur,int ori,int l,int r,int val)
{
cur=++tot;
T[cur]=T[ori];
++T[cur].cnt;
if(l==r)
return ;
int mid=MID(l,r);
if(val<=mid)
update(T[cur].lson,T[ori].lson,l,mid,val);
else
update(T[cur].rson,T[ori].rson,mid+1,r,val);
}
int query(int L,int R,int l,int r,int k)
{
if(l==r)
return l;
int mid=MID(l,r);
int cnt=T[T[R].lson].cnt-T[T[L].lson].cnt;
if(k<=cnt)
return query(T[L].lson,T[R].lson,l,mid,k);
else
return query(T[L].rson,T[R].rson,mid+1,r,k-cnt);
}
int main(void)
{
int T,n,m,l,r,k,i;
scanf("%d",&T);
while (T--)
{
init();
scanf("%d%d",&n,&m);
for (i=1; i<=n; ++i)
{
scanf("%d",&arr[i]);
vec.push_back(arr[i]);
} sort(vec.begin(),vec.end());
vec.erase(unique(vec.begin(),vec.end()),vec.end()); int R=vec.size()-1;//直接离散为0~(size-1)方便后面就不用搞什么+1-1了
//build(root[0],0,R);
for (i=1; i<=n; ++i)
{
arr[i]=lower_bound(vec.begin(),vec.end(),arr[i])-vec.begin();
update(root[i],root[i-1],0,R,arr[i]);
}
for (i=0; i<m; ++i)
{
scanf("%d%d%d",&l,&r,&k);
int indx=query(root[l-1],root[r],0,R,k);
printf("%d\n",vec[indx]);
}
}
return 0;
}

POJ 2104&HDU 2665 Kth number(主席树入门+离散化)的更多相关文章

  1. hdu 2665 Kth number 主席树

    Kth number Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Prob ...

  2. HDU - 2665 Kth number 主席树/可持久化权值线段树

    题意 给一个数列,一些询问,问$[l,r]$中第$K$大的元素是哪一个 题解: 写法很多,主席树是最常用的一种之一 除此之外有:划分树,莫队分块,平衡树等 主席树的定义其实挺模糊, 一般认为就是可持久 ...

  3. poj2104 k-th number 主席树入门讲解

    poj2104 k-th number 主席树入门讲解 定义:主席树是一种可持久化的线段树 又叫函数式线段树   刚开始学是不是觉得很蒙逼啊 其实我也是 主席树说简单了 就是 保留你每一步操作完成之后 ...

  4. hdu 2665 Kth number(划分树模板)

    http://acm.hdu.edu.cn/showproblem.php?pid=2665 [ poj 2104 2761 ]  改变一下输入就可以过 http://poj.org/problem? ...

  5. HDU 2665 Kth number(划分树)

    Kth number Time Limit: 15000/5000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others) Total S ...

  6. hdu 2665 Kth number

    划分树 /* HDU 2665 Kth number 划分树 */ #include<stdio.h> #include<iostream> #include<strin ...

  7. 主席树[可持久化线段树](hdu 2665 Kth number、SP 10628 Count on a tree、ZOJ 2112 Dynamic Rankings、codeforces 813E Army Creation、codeforces960F:Pathwalks )

    在今天三黑(恶意评分刷上去的那种)两紫的智推中,突然出现了P3834 [模板]可持久化线段树 1(主席树)就突然有了不详的预感2333 果然...然后我gg了!被大佬虐了! hdu 2665 Kth ...

  8. poj 2104 K-th Number 主席树+超级详细解释

    poj 2104 K-th Number 主席树+超级详细解释 传送门:K-th Number 题目大意:给出一段数列,让你求[L,R]区间内第几大的数字! 在这里先介绍一下主席树! 如果想了解什么是 ...

  9. SPOJ MKTHNUM & POJ 2104 - K-th Number - [主席树模板题]

    题目链接:http://poj.org/problem?id=2104 Description You are working for Macrohard company in data struct ...

随机推荐

  1. poj 3750 小孩报数问题 解题报告

    题目链接:http://poj.org/problem?id=3750 约瑟夫问题,直接模拟即可. #include <iostream> #include <string> ...

  2. Java性能优化权威指南-读书笔记(二)-JVM性能调优-概述

    概述:JVM性能调优没有一个非常固定的设置,比如堆大小设置多少,老年代设置多少.而是要根据实际的应用程序的系统需求,实际的活跃内存等确定.正文: JVM调优工作流程 整个调优过程是不断重复的一个迭代, ...

  3. August 6th, 2016, Week 32nd, Saturday

    It is not the mountain we conquer, but ourselvess. 我们征服的不是高山,而是我们自己. Difficulties and obstacles, jus ...

  4. hdu 4091 线性规划

    分析转自:http://blog.csdn.net/dongdongzhang_/article/details/7955136 题意 :  背包能装体积为N,  有两种宝石, 数量无限, 不能切割. ...

  5. BZOJ 1010: [HNOI2008]玩具装箱toy 斜率优化DP

    1010: [HNOI2008]玩具装箱toy Description P教授要去看奥运,但是他舍不下他的玩具,于是他决定把所有的玩具运到北京.他使用自己的压缩器进行压缩,其可以将任意物品变成一堆,再 ...

  6. HTTP基础01--web与互联网基础

    WWW构建技术: 把SGML(标准通用标记语言)作为页面文本标记的HTML(超文本标记语言): 作为文档传递协议的HTTP(超文本传输协议):  //严谨应该称为“超文本转移协议”: 指定文档所在地址 ...

  7. javascript操作cookies

    1.读取cookies getCookie: function(c_name){ if (document.cookie.length > 0) { var c_start = document ...

  8. PDA移动开单系统-PDA开单,手机开单,开单APP,移动开单,移动POS开单

    仓库的送货员.收货员.仓管员人手一部PDA,门店可以直接PDA扫描商品下订单或输入编号.拼音码等下订单,订单会直接录入到仓库管理软件中. 仓管在系统中可以一目了然的查询商品库存和订单需求数量.根据库存 ...

  9. 水题 ZOJ 3869 Ace of Aces

    题目传送门 水题,找出出现次数最多的数字,若多个输出Nobody //#include <bits/stdc++.h> //using namespace std; #include &l ...

  10. BZOJ3289 Mato的文件管理(莫队算法+树状数组)

    题目是区间逆序数查询. 莫队算法..左或右区间向左或右延伸时加或减这个区间小于或大于新数的数的个数,这个个数用树状数组来统计,我用线段树超时了.询问个数和数字个数都记为n,数字范围不确定所以离散化,这 ...