POJ2528Mayor's posters（离散化 + 线段树）

题目链接：

题意：给定一些高度都相同的海报去贴，问最后能看见几张海报

The picture below illustrates the case of the sample input.

{ 8,9,10}那张被覆盖看不到，

分析：看了大神们的博客大神是一看就是线段树，可是我都知道是线段树了也不知道怎么做，真是弱的一逼；

线段树分析就是对于每一个海报所在的区间设置一个不同的数字，然后就统计有几个不同的数字即所求解，就是线段树区间更改

技巧：离散化

如果按照这个墙的宽度来设置线段树的话，很大，内存会超。考虑到海报的个数不会很多，所以根据海报的区间的两个端点来进行离散处理，

拿例子来说，{1,4} {2,6} {8,10} {3,4} {7，10} ，所以需要的点为 1， 2， 3， 4， 6， 7， 8 ，10，令x[1] = 1, x[2] = 2，x[3] = 3，x[4] = 4，x[5] = 6，x[6] = 7,x[7] = 8, x[8] = 10，就将原来大的 【 1,10】区间变成了【1,8】这就是离散化

还有一个bug，如果这组样例： {1,10} {1,3} {5,10} 就离散成了 x[1] = 1, x[2] = 3, x[3] = 5, x[4] = 10,

第一张海报时候{1,10}，对于离散化后的处理时，{1,4}

第二张{1,3}， 对于离散化后的就是{1,2}

第三张{5,10}，对于离散化后的就是{3,4}

对于离散化后的来统计，最后结果是2，而实际确实3，原因就是 3到5之间有4而离散化之后就把4给去掉了，这就是一个bug,处理方法就是把相邻的两个数如果差大于1就在添加一个数

 #include <iostream>
 #include <algorithm>
 #include <cstring>
 #include <cstdio>
 using namespace std;
 const int Max = ; //根据海报的个数来设置数组
 struct node
 {
     int l,r;
     int cover; //海报的编号
     int tag;  //懒惰标志
 };
 node tree[Max * ];
 int t[ * Max + ],cnt,res[Max *  + ];
 int a[Max + ],b[Max + ];
 void buildTree(int left, int right, int k)
 {
     tree[k].l = left;
     tree[k].r = right;
     tree[k].cover = ;
     tree[k].tag = -;
     if(left == right)
         return;
     int mid = (left + right) / ;
     buildTree(left, mid, k * );
     buildTree(mid + , right, k *  + );
 }
 int Find(int l, int r, int key, int temp[])
 {
     while(r >= l)
     {
         int mid = (l + r) / ;
         if(temp[mid] == key)
             return mid;
         else if(temp[mid] > key)
         {
             r = mid - ;
         }
         else
         {
             l = mid + ;
         }
     }
     return -;
 }
 void upDate(int left, int right, int k, int num)
 {
     if(tree[k].l == left && tree[k].r == right)
     {
         tree[k].cover = num;
         tree[k].tag = num;
         return;
     }
     if(tree[k].tag != -)
     {
         tree[k * ].tag = tree[k *  + ].tag = tree[k].tag;
         tree[k * ].cover = tree[k *  + ].cover = tree[k].tag;
         tree[k].tag = -;
     }
     int mid = (tree[k].l + tree[k].r) / ;
     if(right <= mid)
     {
         upDate(left, right, k * , num);
     }
     else if(mid < left)
     {
         upDate(left, right, k *  + , num);
     }
     else
     {
         upDate(left, mid, k * , num);
         upDate(mid + , right, k *  + , num);
     }
 }
 void Search(int k)
 {
     if(tree[k].tag != -)
     {
         tree[k].cover = tree[k].tag;
         tree[k * ].tag = tree[k *  + ].tag = tree[k].tag;
         tree[k * ].cover = tree[k *  + ].cover = tree[k].tag;
         tree[k].tag = -;
     }

     if(tree[k].l == tree[k].r)
     {
         res[ tree[k].cover ] = ; // 看看每一个点的海报编号
         return;
     }
     Search(k * );
     Search(k *  + );
 }
 int main()
 {
     int test,n;
     scanf("%d", &test);
     while(test--)
     {
         scanf("%d", &n);
         cnt = ;
         for(int i = ; i <= n; i++)
         {
             scanf("%d%d", &a[i], &b[i]);
             t[ cnt++ ] = a[i];
             t[ cnt++ ] = b[i]; //将所有的端点都放入t中
         }
         sort(t, t + cnt);
         int cnt1 = ;
         for(int i = ; i < cnt; i++)
         {
             if(t[i] != t[i - ])  //去掉相同的
                 t[ cnt1++ ] = t[i];
         }
         for(int i = cnt1 - ; i > ; i--)
         {
             if(t[i] - t[i - ] > ) //如果相邻数差值大于1，就则加一个数
                 t[ cnt1++ ] = t[i - ] + ;
         }
         sort(t, t + cnt1); //加完之后排序，此时已经离散完毕
         for(int i = cnt1; i > ; i--)
             t[i] = t[i - ];
         //使区间为1到cnt1，好处理
         buildTree(, cnt1, );

         for(int i = ; i <= n; i++)
         {
             int left = Find(, cnt1, a[i], t);  //二分查找出每个区间的端点在离散化后的数组中的位置
             int right = Find(, cnt1, b[i], t);
             upDate(left, right, , i);  //更新，设置覆盖位为 i
         }
         memset(res, , sizeof(res));
         Search(); //从根开始查找
         int ans = ;
         for(int i = ; i <= n; i++)
             if(res[i])
             ans++;
         printf("%d\n", ans);
     }
     return ;
 }