[线段树 || 主席树][Hash] HackerRank 101 Hack 49. Sorting Lists

最新推荐文章于 2018-10-16 14:25:33 发布
最新推荐文章于 2018-10-16 14:25:33 发布
阅读量519 收藏
点赞数
分类专栏： 线段树 可持久化数据结构 哈希 文章标签： 线段树 主席树 HASH
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Coldef/article/details/74853059
版权

传送门

这题有两种做法

考场上写了逐位确定的方法，但是没时间调了就交了暴力…

先考虑区间1，如果里面不同的方案数小于k，那么任何一个1为前缀的序列都不是答案，否则1一定是答案的前缀，然后考虑区间2…

可以用hash判重来记录一个区间里的方案数。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <ctime>
#include <map>

using namespace std;

const int N=200010,P1=200003,P2=298223;

typedef unsigned long long ll;

int n,cnt,k;
int a[N],b[N];
int L[N<<1],tot[N<<3],c[N<<3];
int ans[N],ant;
ll mn[N<<3],tag[N<<3];
ll Hash[N<<3],p[N<<1];
map<ll,int> M;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

inline void rea(int &x){
  char c=nc(); x=0;
  for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

void Modify(int g,int l,int r,int L,int R,ll val){
  if(l==L&&r==R) return Hash[g]+=val,void();
  int mid=L+R>>1;
  if(r<=mid) Modify(g<<1,l,r,L,mid,val);
  else if(l>mid) Modify(g<<1|1,l,r,mid+1,R,val);
  else Modify(g<<1,l,mid,L,mid,val),Modify(g<<1|1,mid+1,r,mid+1,R,val);
}

ll Query(int g,int x,int L,int R){
  if(L==R) return Hash[g];
  int mid=L+R>>1;
  if(x<=mid) return Query(g<<1,x,L,mid)+Hash[g];
  else return Query(g<<1|1,x,mid+1,R)+Hash[g];
}

void Add(int g,int x,int L,int R){
  tot[g]++;
  if(L==R) return ;
  int mid=L+R>>1; 
  if(x<=mid) Add(g<<1,x,L,mid);
  else Add(g<<1|1,x,mid+1,R);
}

inline void Push(int g){
  if(tag[g]){
    tag[g<<1]+=tag[g]; mn[g<<1]+=tag[g];
    tag[g<<1|1]+=tag[g]; mn[g<<1|1]+=tag[g];
    tag[g]=0;
  }
  if(c[g]){
    tot[g<<1]=0; tot[g<<1|1]=0; c[g<<1]=c[g<<1|1]=1;
    c[g]=0;
  }
}

inline void Up(int g){
  mn[g]=min(mn[g<<1],mn[g<<1|1]);
  tot[g]=tot[g<<1]+tot[g<<1|1];
}

void Cover(int g,int l,int r,int L,int R,int x){
  if(L==l&&r==R){
    tag[g]+=x; mn[g]+=x;
    return ;
  }
  Push(g); int mid=L+R>>1;
  if(r<=mid) Cover(g<<1,l,r,L,mid,x);
  else if(l>mid) Cover(g<<1|1,l,r,mid+1,R,x);
  else Cover(g<<1,l,mid,L,mid,x),Cover(g<<1|1,mid+1,r,mid+1,R,x);
  Up(g);
}

int Count(int g,int l,int r,int L,int R){
  if(l==L&&r==R) return tot[g];
  int mid=L+R>>1; Push(g);
  if(r<=mid) return Count(g<<1,l,r,L,mid);
  else if(l>mid) return Count(g<<1|1,l,r,mid+1,R);
  else return Count(g<<1,l,mid,L,mid)+Count(g<<1|1,mid+1,r,mid+1,R);
}

void Clear(int g,int l,int r,int L,int R){
  if(l==L&&r==R){
    c[g]=1; tot[g]=0;
    return ;
  }
  int mid=L+R>>1; Push(g);
  if(r<=mid) Clear(g<<1,l,r,L,mid);
  else if(l>mid) Clear(g<<1|1,l,r,mid+1,R);
  else Clear(g<<1,l,mid,L,mid),Clear(g<<1|1,mid+1,r,mid+1,R);
  Up(g);
}

ll findmin(int g,int l,int r,int L,int R){
  if(l==L&&r==R) return mn[g];
  int mid=L+R>>1; Push(g);
  if(r<=mid) return findmin(g<<1,l,r,L,mid);
  else if(l>mid) return findmin(g<<1|1,l,r,mid+1,R);
  return min(findmin(g<<1,l,mid,L,mid),findmin(g<<1|1,mid+1,r,mid+1,R));
}

int main(){
  rea(n); rea(k);
  for(int i=1;i<=n;i++)
    rea(a[i]),rea(b[i]),L[++cnt]=a[i],L[++cnt]=b[i];
  sort(L+1,L+1+cnt); cnt=unique(L+1,L+1+cnt)-L-1;
  for(int i=1;i<=n;i++)
    a[i]=lower_bound(L+1,L+1+cnt,a[i])-L,b[i]=lower_bound(L+1,L+1+cnt,b[i])-L;
  p[0]=1;
  for(int i=1;i<=n;i++) p[i]=p[i-1]*P1;
  for(int i=1;i<=n;i++)
    Modify(1,a[i],b[i]-1,1,cnt,p[i]),Cover(1,a[i],b[i]-1,1,cnt,1);
  for(int i=1;i<=cnt;i++){
    ll h=Query(1,i,1,cnt);
    if(M.count(h)||!h) continue;
    Add(1,i,1,cnt); M[h]=1;
  }
  for(int i=1;i<=n;i++){
    int s=Count(1,a[i],b[i]-1,1,cnt);
    if(s<k)
      k-=s,Clear(1,a[i],b[i]-1,1,cnt);
    else{
      ans[++ant]=i;
      if(findmin(1,a[i],b[i]-1,1,cnt)==1)
    if(!(--k)) break;
      if(1<a[i]) Clear(1,1,a[i]-1,1,cnt),Cover(1,1,a[i]-1,1,cnt,1<<30);
      Clear(1,b[i],cnt,1,cnt); Cover(1,b[i],cnt,1,cnt,1<<30);
      Cover(1,a[i],b[i]-1,1,cnt,-1);
    }
  }
  printf("%d\n",ant);
  for(int i=1;i<=ant;i++) printf("%d ",ans[i]);
  return 0;
}

题解有一种用主席树维护哈希值的方案

考虑用主席树维护每个点被哪些区间覆盖，只要在主席树的节点上加个哈希值。

那么比较两个点，覆盖它的集合的字典序大小，可以在主席树上判断。
要比较两个点x,y，如果ls[x]的哈希值等于ls[y]的哈希值，那么递归比较rs[x]和rs[y]，否则递归比较ls[x]和ls[y]

这样就可以 O(logn) 比较哈希值，再用stl的nth_element就可以
O(nlogn) 得出解

但是这种做法常数有点大…我打的代码在hackerrank上T了三个点…懒的卡常了……

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <ctime>
#include <vector>
#include <map>

using namespace std;

const int N=200010,P=1000007;

typedef unsigned long long ll;

int n,cnt,k;
int a[N],b[N],t[N<<1],gnt,tot;
int L[N<<1],rt[N<<1];
int ls[N*60],rs[N*60];
ll Hash[N],val[N*60];
int ans[N],ant;

vector<int> ap[N<<1],disap[N<<1];
map<ll,int> M;

inline char nc(){
  static char buf[100000],*p1=buf,*p2=buf;
  return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}

inline void rea(int &x){
  char c=nc(); x=0;
  for(;c>'9'||c<'0';c=nc());for(;c>='0'&&c<='9';x=x*10+c-'0',c=nc());
}

void Build(int &g,int l,int r){
  g=++gnt; if(l==r) return ;
  int mid=l+r>>1;
  Build(ls[g],l,mid); Build(rs[g],mid+1,r);
}

void Modify(int g,int &ng,int x,int L,int R,ll h){
  ng=++gnt; ls[ng]=ls[g]; rs[ng]=rs[g]; val[ng]=val[g];
  if(L==R){
    val[ng]+=h; return;
  }
  int mid=L+R>>1;
  if(x<=mid) Modify(ls[g],ls[ng],x,L,mid,h);
  else Modify(rs[g],rs[ng],x,mid+1,R,h);
  val[ng]=val[ls[ng]]+val[rs[ng]];
}

bool check(int x,int y,int L,int R,bool bx,bool by){
  while(L!=R){
    int mid=L+R>>1;
    if(val[ls[x]]!=val[ls[y]]){
      bx|=val[rs[x]]; by|=val[rs[y]];
      R=mid; x=ls[x]; y=ls[y];
    }
    else L=mid+1,x=rs[x],y=rs[y];
  }
  return val[x]?by:!bx;
}

inline bool cmp(int x,int y){ return check(x,y,1,n,0,0); }

bool alive(int g,int x,int L,int R){
  while(L!=R){
    if(!val[g]) return false;
    int mid=L+R>>1;
    if(x<=mid) g=ls[g],R=mid;
    else g=rs[g],L=mid+1;
  }
  return val[g];
}

int main(){
  rea(n); rea(k);
  for(int i=1;i<=n;i++)
    rea(a[i]),rea(b[i]),L[++cnt]=a[i],L[++cnt]=b[i];
  sort(L+1,L+1+cnt); cnt=unique(L+1,L+1+cnt)-L-1;
  Hash[0]=1;
  for(int i=1;i<=n;i++) Hash[i]=Hash[i-1]*P;
  for(int i=1;i<=n;i++){
    a[i]=lower_bound(L+1,L+1+cnt,a[i])-L,b[i]=lower_bound(L+1,L+1+cnt,b[i])-L;
    ap[a[i]].push_back(i); disap[b[i]].push_back(i);
  }
  ll pre=0;
  Build(rt[0],1,n);
  for(int i=1;i<=cnt-1;i++){
    rt[i]=rt[i-1];
    for(int u : ap[i])
      pre+=Hash[u],Modify(rt[i],rt[i],u,1,n,Hash[u]);;
    for(int u : disap[i])
      pre-=Hash[u],Modify(rt[i],rt[i],u,1,n,-Hash[u]);
    if(M.count(pre)||!pre) continue;
    M[pre]=1;
    t[++tot]=rt[i];
  }
  nth_element(t+1,t+k,t+tot+1,cmp);
  for(int i=1;i<=n;i++)
    if(alive(t[k],i,1,n)) ans[++ant]=i;
  printf("%d\n",ant);
  for(int i=1;i<=ant;i++) printf("%d%c",ans[i],i==ant?'\n':' ');
  return 0;
}
LowestJN
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hackkerrank Jogging Cats 枚举
beginend
03-31 416
题意给出n个点m条边的无向图，求四元环数量。 n,m<=100000分析首先有一个很棒的结论，就是如果我们枚举每个度数比某个点大的所有点，那么复杂度就为O(m−−√)O(\sqrt m) 证明：我们设一个点与它相连且度数不小于它的点数为x，那么该点的度数和这x个点的度数必然都不大于x，那么最好的情况就是其所有点的度数都为x，那么有x2<=2mx^2<=2m，从而有x<=2m−−−√x<=\sqr
[HackerRank 101 Hack 42]Array Pairs
待成熟的葡萄
11-04 792
题目大意给定一个nn个数的数组aa，计算出有多少对(i,j)(i,j)满足i<ji<j且ai×aj≤max(ai,ai+1,...,aj−1,aj)a_i\times a_j\le\max(a_i,a_{i+1},...,a_{j-1},a_j)。1≤n≤5×105,1≤ai≤1091\le n\le5\times10^5,1\le a_i\le10^9题目分析这题是一个很优美的暴力。 为了方便求
Hackerrank - Similar Pair 与线段树解法
Hoxily的窝窝
03-13 693
此线段树的节点只有一个数据域，类型为long，其含义是在该节点表示的线段范围里，有多少是满足题意的上级节点。 节点缺失的线段起点与线段终点隐式地存在于query和update方法的segmentBegin、segmentEnd参数中。 即每次query、update方法调用时给出的nodeIndex所指示的节点，其线段的左右端点分别是segmentBegin、segmentEnd。 所以不需要像这样子： class Node { long data; int left; int right; }
2018.10.16 NOIP模拟 长者（主席树+hash）
苟为蒟蒻又何妨
10-16 295
传送门 考试的时候开始sb的以为需要可持久化trietrietrie树，发现建树时空都是O(n2)O(n^2)O(n2)的。 然后发现由于每次只从原来的字符串改一个字符。 因此直接主席树维护区间hashhashhash值。 sortsortsort的时候在主席树上二分比大小。 如果左子树hashhashhash值相同递归比右子树，否则走左子树，因为左子树的字典序的贡献更大。 代码 ...
Hack技巧之选择符级hack
Daisukes的博客
10-20 700
语法： selector{ sRules } 说明： 选择不同的浏览器及版本 尽可能减少对CSS Hack的使用。Hack有风险，使用需谨慎通常如未作特别说明，本文档所有的代码和示例的默认运行环境都为标准模式。一些CSS Hack由于浏览器存在交叉认识，所以需要通过层层覆盖的方式来实现对不同浏览器进行Hack的。 简单列举几个： * html .test { colo
HASH(Trie)-.rar_HashTree.h_TRIE_hash树_trie树_字典树
09-20
**哈希 Trie 树（HashTrie）与字典树（Trie树）详解** 哈希 Trie 树，也称为 HashTrie 或者是哈希化的 Trie 树，是一种结合了哈希表和 Trie 数据结构特点的数据结构。它在 Trie 树的基础上引入了哈希函数，提高了...
STL.rar_hash stl_stl 封装_搜索树
最新发布
09-24
在这个名为"STL.rar_hash stl_stl 封装_搜索树"的压缩包中，我们主要探讨的是STL在哈希表、数据结构封装以及搜索树方面的应用。 1. **STL中的哈希表**： 哈希表是一种能够快速查找的数据结构，STL通过`...
hash_tree_linux.rar_Hash lin_b+tree_hash tree_哈希树
09-22
在IT领域，哈希树（Hash Tree）是一种数据结构，常用于存储和验证大量数据的完整性，尤其是在分布式系统和区块链技术中。哈希树结合了哈希函数和树状结构的特点，提供了一种高效且安全的数据校验方式。标题中的"Hash...
PyPI 官网下载 | hashget-0.114.tar.gz
01-12
《PyPI与Python库：深度解析hashget-0.114.tar.gz》 Python作为一门强大且广泛应用的编程语言，其生态系统中的包管理器PyPI（Python Package Index）是开发者们不可或缺的资源库。PyPI是全球最大的Python软件仓库，...
avl树实现hash表
12-29
在本项目中，“avl树实现hash表”可能是为了利用avl树的特性来优化哈希表的冲突处理。一种可能的实现方式是，每个桶不再是一个简单的链表，而是一个avl树。这样，当冲突发生时，所有映射到同一桶的键会被存储在avl树...
一些好用的hack命令工具
一程山水一程歌
04-03 3399
【命令工具】 ----------------------------------------------------------------------------------------- wget,    非交互式互联网资源下载器，支持 HTTP/HTTPS/FTP 等协议。可用于获取提权工具 或其它 hack工具。 screen,    远程会话管理工具，可以实现多窗口操作、
51nod-1893 Travel-主席树+hash
Fizzmy的博客
03-11 235
传送门 题意： 给出一张n个点，m条边的无向图，每个点有点权，求一条从1到n的路径，使得经过的点中点权大的个数尽量少 n&lt;=100000 Solution： 相当于求一条将这条路径中的所有点权排序后，字典序最小的路径 用主席树维护当前路径经过不同点权的次数，再运用hash可以在logn的时间内判断两个字符串的大小 再加上堆优化的dij，复杂度为O((n+m)lognlogn...
[Hackerrank题目选做] Sorted Subsegments 二分+线段树
Marco_L_T的博客
06-01 755
题目链接：https://www.hackerrank.com/challenges/sorted-subsegments 题目大意:给定n,q,k和一个大小为n的数组A，共有q组操作，每组操作给定l,r，要求将A[l]...A[r]按照升序排序，q组操作后求A[k]的值。(n,q Part 1  骗分 菜鸡并不会这样的神题水题，只能按照万年不变的骗分策略去小数据暴力，大数据贪心， 可是-
[主席树维护HASH] Codechef. Cloning
CE玩家
08-29 389
传送门直接用主席树维护HASH比较就可以了吧…#include <cstdio> #include <algorithm> #include <iostream>using namespace std;typedef unsigned long long ll;const int N=100010; const ll base=100003;int t,n,q,cnt; int a[N],rt[N]
HackerRank Algorithms-Search-Pairs 数组的固定差对数
jishublog
09-07 117
题目点此 糊里糊涂地就在HackerRank做了几题水题，姑且发出来吧。。。 题意：给出n和k，然后给出n个数，求出数组里面两两数的差为k有几对。 其中[N&lt;=10^5],[K&gt;0 and K&lt;1e9]，所有数都在int范围内，很明显，如果裸暴力的话肯定会超时。（虽然HackerRank好像没有时间限制，越快分数越高。。。） 于是换种写法，遍历数组然后查询该数+k有没有存...
[主席树维护HASH && SET维护DFS序] Codechef. Walks on the binary tree
CE玩家
08-29 410
传送门每次加一个串 x 会增加 n-max{LCP(x,i)}，因为是树上，max{LCP(x,i)}就肯定是dfs序中跟它相邻的点，也就是它们的lca深度最深。 那么就用set维护一下dfs序，比较的话，用主席树维护hash#include <cstdio> #include <iostream> #include <algorithm> #include <set> #include <cst
[线段树维护BITSET] NOI2017 .Day1 T1 整数
CE玩家
07-24 1795
把数转换成二进制维护 那么进位就是把之后一段连续1变成0，后面的0变成1 退位就是把之后一段连续的0变成1，后面的1变成0 这样可以用线段树维护 有一个nlog2nn\log^2n的暴力，就是把这个数的每一个为1的位取出来，用线段树加进去，a为负的同理如果把原来的01序列压位一下（我压了30位），那么a最多跨2个30位整数，把这两位取出来，拼成一个60位整数，然后把加上去，因为最多进（退）一
[AtCoder ARC076 .F] [二分图] [霍尔定理] Exhausted?
CE玩家
07-02 1713
注意到这个模型可以转化成二分图 根据霍尔定理，对于任意S∈US\in U，都要满足S≥N(S)S\ge N(S)，其中UU是全集，N(S)N(S)是与SS相连的点组成的集合。 因为N(S)N(S)都是一些在左边，一些在右边的形式，所以只要枚举一下N(S)N(S)，用线段树维护一下|S||S|的最大值就可以了。#include <cstdio> #include <iostream> #inclu
优化查询：哈希表与字典树在大规模数据中的应用
在数据结构的学习中，哈希表和字典树是两个重要的概念，尤其是在处理大量数据和高效查询的问题中。哈希表，又称为散列表，是一种通过哈希函数将键映射到数组索引的数据结构，常用于实现快速查找、插入和删除操作。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值