POJ_2528_Mayor's posters

//这题的数据比较水,可以参见http://blog.youkuaiyun.com/metalseed/article/details/8039326里关于这题的解释,然后可以发现网上的AC代码都是由于数据简单的

//原因水过去的.然后我的做法并没用延时标记,用的是子区间向父区间推导,找到最大的color.

#include<iostream>
#include<cstdio>
#include<sstream>    
#include<string>    
#include<vector>    
#include<list>    
#include<set>    
#include<map>    
#include<stack>    
#include<queue>    
#include<algorithm>    
#include<cmath>    
#pragma warning(disable:4996)    
using std::cin;
using std::cout;
using std::endl;
using std::stringstream;
using std::string;
using std::vector;
using std::list;
using std::pair;
using std::set;
using std::multiset;
using std::map;
using std::multimap;
using std::stack;
using std::queue;
template<typename ElemType>
class Interval
{
public:
	ElemType first, second, color, increment;
	Interval()
	{
		first = second = color = increment = 0;
	}
	Interval(const ElemType &f, const ElemType &s)
	{
		first = f;
		second = s;
		color = increment = 0;
	}
	Interval(const pair<ElemType, ElemType>&p)
	{
		first = p.first;
		second = p.second;
		color = 0;
	}
	ElemType mid()
	{
		return first + (length() - 1) / 2;
	}
	ElemType length()
	{
		return second - first + 1;
	}
};
template<typename ElemType>
class SegTree
{
public:
	vector<Interval<ElemType> >tree;
	SegTree() {}
	SegTree(const ElemType &n)
	{
		tree.resize(4 * n);
	}
	int size()
	{
		return tree.size();
	}
	void resize(const ElemType &n)
	{
		tree.resize(n);
	}
	//以数组形式建立线段树,当数据离散化之后,调用build(min,max,1)
	void build(Interval<ElemType>interval, ElemType parent,ElemType &leaf,ElemType &size)
	{
		tree[parent] = interval;
		if (interval.first == interval.second)
		{
			leaf = std::min(leaf, parent);
			size = std::max(size, parent);
			return;//当为元线段时停止递归
		}
		ElemType mid = (interval.first + interval.second) / 2;
		build({ interval.first,mid }, 2 * parent,leaf, size);
		build({ mid + 1,interval.second }, 2 * parent + 1,leaf, size);
	}
	//给闭区间都染上color
	void insert(Interval<ElemType>interval, ElemType parent, const ElemType &color)
	{
		if (tree[parent].first == interval.first&&interval.second == tree[parent].second)
		{
			tree[parent].color = color;
			return;
		}
		ElemType mid = tree[parent].mid();
		if (interval.second <= mid)
		{
			insert(interval, parent * 2, color);
		}
		else if (interval.first > mid)
		{
			insert(interval, parent * 2 + 1, color);
		}
		else
		{
			insert({ interval.first,mid }, parent * 2, color);
			insert({ mid + 1,interval.second }, parent * 2 + 1, color);
		}
	}
	int getColor(int child)
	{
		if (child == 1)
		{
			return tree[child].color;
		}
		return  std::max(tree[child].color, getColor(child / 2));
	}
};
vector<pair<int, int> >discretize(int &size)
{
	int amount; 
	scanf("%d", &amount);
	map<int, int>Map;
	vector<pair<int, int> >interval;
	while (amount--)
	{
		int left, right;
		scanf("%d%d", &left,&right);
		interval.push_back({ left,right });
		Map.insert({ left,0 });
		Map.insert({ right,0 });
	}
	int i = 0;
	for (map<int, int>::iterator iter = Map.begin(); iter != Map.end(); iter++)
	{
		iter->second = ++i;
	}
	size = i;
	for (size_t i = 0; i < interval.size(); i++)
	{
		interval[i].first = Map[interval[i].first];
		interval[i].second = Map[interval[i].second];
	}
	return interval;
}
int main()
{
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt","w",stdout); 
	int T; cin >> T;
	while (T--)
	{
		int size = 0,leaf=2000000000;
		vector<pair<int, int> >interval = discretize(size);
		SegTree<int> segtree(size + 1);
		segtree.build({ 1,size }, 1,leaf, size);
		segtree.resize(size + 1);
		for (size_t i = 0; i < interval.size(); i++)
		{
			segtree.insert(interval[i], 1, i + 1);
		}
		set<int>Set;
		for (int i = leaf; i < segtree.size(); i++)
		{
			if (segtree.tree[i].first&&segtree.tree[i].first == segtree.tree[i].second)
			{
				Set.insert(segtree.getColor(i));
			}
		}
		cout << Set.size() << endl;
	}
	return 0;
}