[线段树+离散化+单点查询] HDOJ - 4325 Flowers

最新推荐文章于 2019-04-24 11:41:27 发布

weixin_33843409

最新推荐文章于 2019-04-24 11:41:27 发布

阅读量81

点赞数

原文链接：http://www.cnblogs.com/tclh123/archive/2012/08/01/6171751.html

版权

一年没写线段树, 全凭回忆加YY能1A好哈皮..............

很裸的线段树, 就是需要先离散化.

离散化我记得有lower_bound这种东西, 但是想不起来怎么用了...所以这里是YY了用了个map然后O(n)循环进行离散值对应...

预备:

1/ STL - unique, 接受两个指针(第三个参数为可选自定义相等比较器, 相等返回true), 实现呢就是从头到尾扫一遍, 利用相等元素相邻(若不满足则要先sort). 将区间重复的元素都放到末尾, 返回前面不重复区间的最后一个元素地址.

template <class ForwardIterator>
  ForwardIterator unique ( ForwardIterator first, ForwardIterator last )
{
  ForwardIterator result=first;
  while (++first != last)
  {
    if (!(*result == *first))  // or: if (!pred(*result,*first)) for the pred version
      *(++result)=*first;
  }
  return ++result;
}

2/ STL - lower_bound, 接受两个指针跟要找的值(第四个可选参数为自定义小于比较器, 小于返回true), 用于在有序的区间中查找首个不小于(小于等于)某值的元素（大于等于某值）, 返回下确界元素的地址. 目测用的二分.

template <class ForwardIterator, class T>
  ForwardIterator lower_bound ( ForwardIterator first, ForwardIterator last, const T& value )
{
  ForwardIterator it;
  iterator_traits<ForwardIterator>::distance_type count, step;
  count = distance(first,last);
  while (count>0)
  {
    it = first; step=count/2; advance (it,step);
    if (*it<value)                   // or: if (comp(*it,value)), for the comp version
      { first=++it; count-=step+1;  }
    else count=step;
  }
  return first;
}

下面给出利用unique / lower_bound 来进行离散化的部分代码:

sort(all, all+idx);
int tot = unique(all, all+idx) - all;
build(1, tot, 1);
...
int x = lower_bound(all, all+tot, st[i]) - all;
int y = lower_bound(all, all+tot, en[i]) - all;

简言之就是, 用unique来剔除重复元素, 用lower_bound来查找元素位置(unique后的区间已经是不重复的了, 所以只是查找而已, 所以你甚至可以用upper_bound, 只不过upper_bound返回的是大于value()不包含等于, 所以要用 upper_bound(...)-1, 等价于 lower_bound(...) ).

代码(原先):

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
int Rint() { int x; scanf("%d", &x); return x; }
#define FOR(i, a, b) for(int i=(a); i<=(b); i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(x) for(int i=0; i<(x); i++)
typedef long long int64;
#define INF (1<<30)
#define bug(s) cout<<#s<<"="<<s<<" "

#define MAXN 100002
struct node
{
	int l, r, v;
	int add;		//lazy-add
}a[MAXN*2*4];	//1-th		//10^9离散化, 10^5条线段, 最多可能产生 2*10^5个点

void pushdown(int e)
{
	if(a[e].add)
	{
		if(a[e].l != a[e].r)		//若不是叶子, 则下推
		{
			a[e<<1].add += a[e].add;
			a[e<<1|1].add += a[e].add;
			//pushdown(e<<1);		//不能递归下推, 不然也不是lazy了
			//pushdown(e<<1|1);
		}
		a[e].v += a[e].add;
		a[e].add = 0;
	}
}

void build(int l, int r, int e)
{
	a[e].l = l;
	a[e].r = r;
	a[e].v = a[e].add = 0;
	if(l == r)
	{
		return;
	}
	else
	{
		int mid = (l+r)>>1;
		build(l, mid, e<<1);
		build(mid+1, r, e<<1|1);
	}
}

void add(int l, int r, int e)
{
	//if(l!=r)		//不用到叶子节点, 不然延迟处理就没意义了, 效率退化必TLE~- -
	if(l<=a[e].l && a[e].r<=r)
	{
		a[e].add += 1;
	}
	else
	{
		int mid = (a[e].l+a[e].r)>>1;
		if(l<=mid)
			add(l, r, e<<1);
		if(mid+1<=r)			//注意是 mid+1
			add(l, r, e<<1|1);
	}
}

int query(int e, int p)
{
	pushdown(e);
	if(a[e].l == p && a[e].r == p)
	{
		return a[e].v;
	}
	else
	{
		//pushdown(e);			//在这里推不够下...wa1

		int mid = (a[e].l+a[e].r)>>1;
		if(p<=mid)				//mid算 左边?
			return query(e<<1, p);
		else
			return query(e<<1|1, p);
	}
}

int n, m;		//m = query times
int st[MAXN], en[MAXN];
int q[MAXN];
int all[MAXN*3];
int idx;
map<int, int> tolow;	//	e.g. tolow[234] = 1;

int main()
{
	int t = Rint();
	FOR(T, 1, t)
	{
		tolow.clear();
		idx = 0;
		printf("Case #%d:\n", T);
		n = Rint();
		m = Rint();
		REP(n)
		{
			st[i] = Rint();
			en[i] = Rint();
			all[idx++] = st[i];
			all[idx++] = en[i];
		}
		REP(m)
		{
			q[i] = Rint();
			all[idx++] = q[i];
		}
		sort(all, all+idx);
		int rank = 1;
		REP(idx)
		{
			int v = all[i];
			if(tolow[v]) continue;
			tolow[v] = rank++;		//离散后的值从1开始
		}
		int tot = tolow.size();
		build(1, tot, 1);
		REP(n)
		{
			add(tolow[st[i]], tolow[en[i]], 1);
		}
		REP(m)
		{
			int ans = query(1, tolow[q[i]]);
			printf("%d\n", ans);
		}
	}
}

代码(lower_bound):

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
int Rint() { int x; scanf("%d", &x); return x; }
#define FOR(i, a, b) for(int i=(a); i<=(b); i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(x) for(int i=0; i<(x); i++)
typedef long long int64;
#define INF (1<<30)
#define bug(s) cout<<#s<<"="<<s<<" "

#define MAXN 100002
struct node
{
	int l, r, v;
	int add;		//lazy-add
}a[MAXN*2*4];	//1-th		//10^9离散化, 10^5条线段, 最多可能产生 2*10^5个点

void pushdown(int e)
{
	if(a[e].add)
	{
		if(a[e].l != a[e].r)		//若不是叶子, 则下推
		{
			a[e<<1].add += a[e].add;
			a[e<<1|1].add += a[e].add;
			//pushdown(e<<1);		//不能递归下推, 不然也不是lazy了
			//pushdown(e<<1|1);
		}
		a[e].v += a[e].add;
		a[e].add = 0;
	}
}

void build(int l, int r, int e)
{
	a[e].l = l;
	a[e].r = r;
	a[e].v = a[e].add = 0;
	if(l == r)
	{
		return;
	}
	else
	{
		int mid = (l+r)>>1;
		build(l, mid, e<<1);
		build(mid+1, r, e<<1|1);
	}
}

void add(int l, int r, int e)
{
	//if(l!=r)		//不用到叶子节点, 不然延迟处理就没意义了, 效率退化必TLE~- -
	if(l<=a[e].l && a[e].r<=r)
	{
		a[e].add += 1;
	}
	else
	{
		int mid = (a[e].l+a[e].r)>>1;
		if(l<=mid)
			add(l, r, e<<1);
		if(mid+1<=r)			//注意是 mid+1
			add(l, r, e<<1|1);
	}
}

int query(int e, int p)
{
	pushdown(e);
	if(a[e].l == p && a[e].r == p)
	{
		return a[e].v;
	}
	else
	{
		//pushdown(e);			//在这里推不够下...wa1

		int mid = (a[e].l+a[e].r)>>1;
		if(p<=mid)				//mid算 左边?
			return query(e<<1, p);
		else
			return query(e<<1|1, p);
	}
}

int n, m;		//m = query times
int st[MAXN], en[MAXN];
int q[MAXN];
int all[MAXN*3];
int idx;
map<int, int> tolow;	//	e.g. tolow[234] = 1;

int main()
{
	int t = Rint();
	FOR(T, 1, t)
	{
		tolow.clear();
		idx = 0;
		printf("Case #%d:\n", T);
		n = Rint();
		m = Rint();
		REP(n)
		{
			st[i] = Rint();
			en[i] = Rint();
			all[idx++] = st[i];
			all[idx++] = en[i];
		}
		REP(m)
		{
			q[i] = Rint();
			all[idx++] = q[i];
		}
		sort(all, all+idx);
		int tot = unique(all, all+idx) - all;
		build(1, tot, 1);
		REP(n)
		{
			int x = lower_bound(all, all+tot, st[i]) - all + 1;
			int y = lower_bound(all, all+tot, en[i]) - all + 1;
			add(x, y, 1);
		}
		REP(m)
		{
			int x = lower_bound(all, all+tot, q[i]) - all + 1;
			int ans = query(1, x);
			printf("%d\n", ans);
		}
	}
}

代码(upper_bound):

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<string>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
int Rint() { int x; scanf("%d", &x); return x; }
#define FOR(i, a, b) for(int i=(a); i<=(b); i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(x) for(int i=0; i<(x); i++)
typedef long long int64;
#define INF (1<<30)
#define bug(s) cout<<#s<<"="<<s<<" "

#define MAXN 100002
struct node
{
	int l, r, v;
	int add;		//lazy-add
}a[MAXN*2*4];	//1-th		//10^9离散化, 10^5条线段, 最多可能产生 2*10^5个点

void pushdown(int e)
{
	if(a[e].add)
	{
		if(a[e].l != a[e].r)		//若不是叶子, 则下推
		{
			a[e<<1].add += a[e].add;
			a[e<<1|1].add += a[e].add;
			//pushdown(e<<1);		//不能递归下推, 不然也不是lazy了
			//pushdown(e<<1|1);
		}
		a[e].v += a[e].add;
		a[e].add = 0;
	}
}

void build(int l, int r, int e)
{
	a[e].l = l;
	a[e].r = r;
	a[e].v = a[e].add = 0;
	if(l == r)
	{
		return;
	}
	else
	{
		int mid = (l+r)>>1;
		build(l, mid, e<<1);
		build(mid+1, r, e<<1|1);
	}
}

void add(int l, int r, int e)
{
	//if(l!=r)		//不用到叶子节点, 不然延迟处理就没意义了, 效率退化必TLE~- -
	if(l<=a[e].l && a[e].r<=r)
	{
		a[e].add += 1;
	}
	else
	{
		int mid = (a[e].l+a[e].r)>>1;
		if(l<=mid)
			add(l, r, e<<1);
		if(mid+1<=r)			//注意是 mid+1
			add(l, r, e<<1|1);
	}
}

int query(int e, int p)
{
	pushdown(e);
	if(a[e].l == p && a[e].r == p)
	{
		return a[e].v;
	}
	else
	{
		//pushdown(e);			//在这里推不够下...wa1

		int mid = (a[e].l+a[e].r)>>1;
		if(p<=mid)				//mid算 左边?
			return query(e<<1, p);
		else
			return query(e<<1|1, p);
	}
}

int n, m;		//m = query times
int st[MAXN], en[MAXN];
int q[MAXN];
int all[MAXN*3];
int idx;
map<int, int> tolow;	//	e.g. tolow[234] = 1;

int main()
{
	int t = Rint();
	FOR(T, 1, t)
	{
		tolow.clear();
		idx = 0;
		printf("Case #%d:\n", T);
		n = Rint();
		m = Rint();
		REP(n)
		{
			st[i] = Rint();
			en[i] = Rint();
			all[idx++] = st[i];
			all[idx++] = en[i];
		}
		REP(m)
		{
			q[i] = Rint();
			all[idx++] = q[i];
		}
		sort(all, all+idx);
		int tot = unique(all, all+idx) - all;
		build(1, tot, 1);
		REP(n)
		{
			int x = upper_bound(all, all+tot, st[i]) - all;	//upper_bound: 查找首个大于value（或comp比较为真）的上确界元素
			int y = upper_bound(all, all+tot, en[i]) - all;
			add(x, y, 1);
		}
		REP(m)
		{
			int x = upper_bound(all, all+tot, q[i]) - all;
			int ans = query(1, x);
			printf("%d\n", ans);
		}
	}
}

转载于:https://www.cnblogs.com/tclh123/archive/2012/08/01/6171751.html

weixin_33843409

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[线段树+离散化+单点查询] HDOJ - 4325 Flowers

一年没写线段树, 全凭回忆加YY能1A好哈皮..............很裸的线段树, 就是需要先离散化.离散化我记得有lower_bound这种东西, 但是想不起来怎么用了...所以这里是YY了用了个map然后O(n)循环进行离散值对应...预备:1/ STL - unique, 接受两个指针(第三个参数为可选自定义相等比较器, 相等返回true), 实现呢就是从...
复制链接

扫一扫