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 + 10;
set< pair<int, int> > S;
struct Seg{
    int l, r, h;
    int lazy;
}seg[maxn << 2];
int n, m, I, H;

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

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

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

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

int main(){
    while(~scanf("%d%d%d%d", &n, &I, &H, &m)){
        build(1, 1, n + 1);
        S.clear();
        for(int i = 0, 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(1, 1, n + 1, u + 1, v);
        }
        query(1, 1, n + 1);
    }
    return 0;
}