poj3263 Tallest Cow

题意略去。

考虑给定的R对pair(A, B)。

即A能看见B，这意味着B不比A低，并且区间内部的所有元素的高度严格小于A的高度。

我们规定区间的方向：若A > B,为反方向，反之称为正方向。

容易发现，区间在同一方向上不交叉，即要么相离，要么相互包含。

在相反反方向上，若两区间不相互包含，必定是有且仅有一个公共区间端点。

首先将所有idx上的高度默认设置为H。

对于相离的区间，他们之间的计算是独立的。

考虑相互包含的区间，先考虑范围最大的那个区间，处理之间闭区间[A,B]上的高度是相同的，满足此条件只需令(A,B)区间内元素自减一。

递归考虑其包含的区间，显然这样的做法是最优的且合法的。

实际上这与考虑区间的次序无关。

即每得到一个区间，对开区间内的元素减一即可。

可以用线段树来做区间的修改操作。

http://poj.org/problem?id=3263

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <set>
 using namespace std;
 const int maxn = 1e4 + ;
 set< pair<int, int> > S;
 struct Seg{
     int l, r, h;
     int lazy;
 }seg[maxn << ];
 int n, m, I, H;

 void build(int u, int l, int r){
     seg[u].l = l;
     seg[u].r = r;
     seg[u].lazy = ;
     seg[u].h = H;
     if(r - l < ) return;
     int mid = (l + r) >> ;
     build(u << , l, mid);
     build(u <<  | , mid, r);
 }

 void push_down(int u){
     if(seg[u].lazy >  && seg[u].r - seg[u].l > ){
         int mid = (seg[u].l + seg[u].r) >> ;
         seg[u << ].lazy += seg[u].lazy;
         seg[u <<  | ].lazy += seg[u].lazy;
         seg[u << ].h -= seg[u].lazy;
         seg[u <<  | ].h -= seg[u].lazy;
         seg[u].lazy = ;
     }
 }

 void update(int u, int l, int r, int L, int R){
     if(R - L < ) return;
     if(L == l && r == R){
         seg[u].lazy++;
         seg[u].h--;
         return;
     }
     push_down(u);
     int mid = (l + r) >> ;
     if(R <= mid) update(u << , l, mid, L, R);
     else if(L >= mid) update(u <<  | , mid, r, L, R);
     else{
         update(u << , l, mid, L, mid);
         update(u <<  | , mid, r, mid, R);
     }
 }

 void query(int u, int l, int r){
     if(r - l == ){
         printf("%d\n", seg[u].h);
         return;
     }
     push_down(u);
     int mid = (l + r) >> ;
     query(u << , l, mid);
     query(u <<  | , mid, r);
 }

 int main(){
     while(~scanf("%d%d%d%d", &n, &I, &H, &m)){
         build(, , n + );
         S.clear();
         for(int i = , u, v; i < m; i++){
             scanf("%d%d", &u, &v);
             if(u == v || S.find(make_pair(u, v)) != S.end()) continue;
             S.insert(make_pair(u, v));
             if(u > v) swap(u, v);
             update(, , n + , u + , v);
         }
         query(, , n + );
     }
     return ;
 }