POJ 2528 (线段树 离散化) Mayor's posters

离散化其实就是把所有端点放在一起，然后排序去个重就好了。

比如说去重以后的端点个数为m，那这m个点就构成m-1个小区间。然后给这m-1个小区间编号1~m-1，再用线段树来做就行了。

具体思路是，从最后一张的海报来判断，如果海报覆盖的区域有空白区域那么这张海报就是可见的。并及时更新线段树信息。

说一个我调了很久的才发现小错误，比如书2 2这样一个海报，如果你把这张海报的左右端点都记作2的话那就是个空区间了。

其实，这张海报覆盖的是第2块瓷砖。所以R++，2 3就表示第2块瓷砖的左右端点。

当然，如果不是我这个思路，就可能不会出现这个问题。

这个是跟着去年北大的ACM培训班上给的标程写的，指针满天飞，个人感觉代码不够简洁。

//#define LOCAL
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;

int n;
struct CPost
{
    int L, R;
}posters[10000 + 100];
int x[20000 + 200];    //海报的端点瓷砖编号
int hash[10000000 + 10];//hash[i]表示瓷砖i所处的离散化后的区间编号

struct CNode
{
    int L, R;
    bool bCovered;    //区间[L, R]是否已经完全覆盖
    CNode *pLeft, *pRight;
}Tree[1000000];
int nNodeCount = 0;
int Mid(CNode* pRoot)
{
    return (pRoot->L + pRoot->R) / 2;
}
void BuildTree(CNode *pRoot, int L, int R)
{
    pRoot->L = L;
    pRoot->R = R;
    pRoot->bCovered = false;
    if(L == R)
        return;
    ++nNodeCount;
    pRoot->pLeft = Tree + nNodeCount;
    ++nNodeCount;
    pRoot->pRight = Tree + nNodeCount;
    BuildTree(pRoot->pLeft, L, (L+R)/2);
    BuildTree(pRoot->pRight, (L+R)/2+1, R);
}
bool Post(CNode *pRoot, int L, int R)
{//插入一张覆盖区间[L, R]的海报，返回true则说明该区间是部分或者全部可见的
    if(pRoot->bCovered)
        return false;
    if(pRoot->L == L && pRoot->R == R)
    {
        pRoot->bCovered = true;
        return true;
    }
    bool bResult;
    if(R <= Mid(pRoot))
        bResult = Post(pRoot->pLeft, L, R);
    else if(L >= Mid(pRoot) + 1)
        bResult = Post(pRoot->pRight, L, R);
    else
    {
        bool b1 = Post(pRoot->pLeft, L, Mid(pRoot));
        bool b2 = Post(pRoot->pRight, Mid(pRoot) + 1, R);
        bResult = b1 || b2;
    }
    //要更新的节点的覆盖情况
    if(pRoot->pLeft->bCovered && pRoot->pRight->bCovered)
        pRoot->bCovered = true;
    return bResult;
}

int main(void)
{
    #ifdef LOCAL
        freopen("2528in.txt", "r", stdin);
    #endif
    int t;
    int i, j, k;
    scanf("%d", &t);
    int nCaseNo = 0;
    while(t--)
    {
        ++nCaseNo;
        scanf("%d", &n);
        int nCount = 0;
        for(i = 0; i < n; ++i)
        {
            scanf("%d%d", &posters[i].L, &posters[i].R);
            x[nCount++] = posters[i].L;
            x[nCount++] = posters[i].R;
        }
        sort(x, x + nCount);
        nCount = unique(x, x + nCount) - x;//元素去重
        //将下面离散化
        int nIntervalNo = 0;
        for(i = 0; i < nCount; ++i)
        {
            hash[x[i]] = nIntervalNo;
            if(i < nCount - 1)
            {
                if(x[i + 1] - x[i] == 1)
                    ++nIntervalNo;
                else
                    nIntervalNo += 2;
            }
        }

        BuildTree(Tree, 0, nIntervalNo);
        int nSum = 0;
        for(i = n - 1; i >= 0; --i)
        {//从后往前遍历每个海报是否可见
            if(Post(Tree, hash[posters[i].L], hash[posters[i].R]))
                ++nSum;
        }
        printf("%d
", nSum);
    }
    return 0;
}

自己改成数组的写法，感觉可读性要好很多。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 100000 + 10;
int covered[maxn << 2];
int n, m, L[maxn], R[maxn], x[maxn];

bool post(int o, int L, int R, int qL, int qR)
{
    if(covered[o]) return false;
    if(qL == L && qR == R) { covered[o] = true; return true; }
    int M = (L + R) / 2;
    bool ok;
    if(qR <= M) ok = post(o*2, L, M, qL, qR);
    else if(qL > M) ok = post(o*2+1, M+1, R, qL, qR);
    else
    {
        bool ok1 = post(o*2, L, M, qL, M);
        bool ok2 = post(o*2+1, M+1, R, M+1, qR);
        ok = ok1 || ok2;
    }
    if(covered[o*2] && covered[o*2+1]) covered[o] = true;
    return ok;
}

int main()
{
    //freopen("in.txt", "r", stdin);

    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        for(int i = 0; i < n; i++)
        {
            scanf("%d%d", &L[i], &R[i]);
            R[i]++;
            x[i*2] = L[i]; x[i*2+1] = R[i];
        }
        sort(x, x + n * 2);
        m = unique(x, x + n * 2) - x;

        memset(covered, false, sizeof(covered));
        int ans = 0;
        for(int i = n - 1; i >= 0; i--)
        {
            int qL = lower_bound(x, x + m, L[i]) - x + 1;
            int qR = lower_bound(x, x + m, R[i]) - x;
            if(post(1, 1, m, qL, qR)) ans++;
        }
        printf("%d
", ans);
    }

    return 0;
}

还有一种方法就是正向模拟，用setv[o]来表示该节点被哪张海报覆盖，此时线段树的功能就是区间替换。

最后查询的时候就看这些节点被哪张海报覆盖，注意有的海报可能会覆盖多个节点，为了避免重复统计，可以用一个bool标记数组。

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

const int maxn = 20000 + 10;
int setv[maxn << 2];
bool is_cnt[maxn];

int L[maxn], R[maxn], x[maxn];
int n, m, qL, qR, v, ans;

void pushdown(int o)
{
    if(setv[o] >= 0)
    {
        setv[o*2] = setv[o*2+1] = setv[o];
        setv[o] = -1;
    }
}

void update(int o, int L, int R)
{
    if(qL <= L && qR >= R) { setv[o] = v; return; }
    pushdown(o);
    int M = (L + R) / 2;
    if(qL <= M) update(o*2, L, M);
    if(qR > M) update(o*2+1, M+1, R);
}

void query(int o, int L, int R)
{
    if(setv[o] >= 0)
    {
        if(!is_cnt[setv[o]]) { ans++; is_cnt[setv[o]] = true; }
        return;
    }
    if(L == R) return;
    int M = (L + R) / 2;
    query(o*2, L, M);
    query(o*2+1, M+1, R);
}

int main()
{
    //freopen("in.txt", "r", stdin);

    int T; scanf("%d", &T);
    while(T--)
    {
        scanf("%d", &n);
        for(int i = 0; i < n; i++)
        {
            scanf("%d%d", &L[i], &R[i]);
            R[i]++;
            x[i*2] = L[i]; x[i*2+1] = R[i];
        }
        sort(x, x + n * 2);
        m = unique(x, x + n * 2) - x;

        memset(setv, -1, sizeof(setv));
        memset(is_cnt, false, sizeof(is_cnt));

        for(int i = 0; i < n; i++)
        {
            v = i;
            qL = lower_bound(x, x + m, L[i]) - x + 1;
            qR = lower_bound(x, x + m, R[i]) - x;
            update(1, 1, m - 1);
        }
        ans = 0;
        query(1, 1, m - 1);
        printf("%d
", ans);
    }

    return 0;
}