hihocoder-1079题解（线段树+离散化）

一、题目链接

　　http://hihocoder.com/problemset/problem/1079

二、题意

　　给定一个长度为L的区间，给你n个子区间，每一个区间涂成一种颜色，问最后这个区间内有几种不同的颜色。

三、思路

　　这题和http://poj.org/problem?id=2528题意几乎一模一样，所以，我一开始就毫不犹豫地把POJ这题的思路重新敲了一遍，样例一测，没问题，提交上去，WA。然后，我意识到了，因为POJ的这题数据特别水，对于[1, 10]，[1, 4]，[6, 10]这种样例，离散化之后变成[1, 4]，[1, 2]，[3, 4]。原本答案应该是3的变成了2，然而POJ就是能过，也太水了点。

　　然后，我用另外一种方式离散化后（具体见附录一），把这个问题给解决了，提交上去，还是WA。

　　思考良久，测了很多样例，都没发现有什么错误，突然，脑子中灵光一闪，莫非这种区间是连续的？也就是说：[1, 2]，[3, 4]这两段区间不是连续的，因为区间[2, 3]之间没涂色。而我们平时处理离散区间的时候，[1, 2]代表位置1和2，[3, 4]代表位置3和4，所以，在离散区间的问题中，这是连续的；但是在连续区间问题中，这不连续。那么，该怎么变呢？

　　只要把修改节点的值所代表的意义即可。原来叶子节点代表的是：[i, i]区间内，也就是第i个元素的信息。现在变成，叶子节点表示：[i, i + 1]这段小区间的信息。换句话说，原来维护的是点（单点或多点）的信息，现在变成维护区间的信息，其他都是一样的。那么，刚刚那个离散化带来的问题怎么处理呢？由于我们维护的是区间的信息，对于[1, 10]，[1, 4]，[5, 10]这种样例，现在维护的是区间信息，修改[1, 4]和[5, 10]区间时，[4, 5]区间一直没被修改，所以，自然也不会影响我们的查询。因此，原本维护点信息时离散化带来的问题，变成维护区间后，直接被和谐了，多么愉快的一件事啊！

四、源代码

　　

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> PII;
const int MAXN = 1e5 + 10;
int n, m;
int nn, mm;
PII ranges[MAXN];
int all[MAXN << 2];
int color[MAXN << 2];

void pushDown(int root) {
    if(~color[root]) {
        color[root << 1] = color[root];
        color[root << 1 | 1] = color[root];
        color[root] = -1;
    }
}

void update(int ul, int ur, int val, int root = 1, int l = 0, int r = mm - 1) {
    if(l >= r)return;
    if(l > ur || r < ul)return;
    if(l >= ul && r <= ur) {
        color[root] = val;
        return;
    }
    if(r - l > 1) {
        pushDown(root);
        int mid = (l + r) >> 1;
        if(mid - l >= 1)update(ul, ur, val, root << 1, l, mid);
        if(r - mid >= 1)update(ul, ur, val, root << 1 | 1, mid, r);
    }
}

set<int> ans;
void query(int ql, int qr, int root = 1, int l = 0, int r = mm - 1) {
    if(l > qr || r < ql)return;
    if(r - l == 1) {
        if(color[root] == -1)return;
        ans.insert(color[root]);
        return;
    }
    if(r - l > 1) {
        pushDown(root);
        int mid = (l + r) >> 1;
        if(mid - l >= 1)query(ql, qr, root << 1, l, mid);
        if(r - mid >= 1)query(ql, qr, root << 1 | 1, mid, r);
    }
}

int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int a, b;
    while(~scanf("%d%d", &n, &m)) {
        nn = 0;
        memset(color, -1, sizeof(color));
        for(int i = 0; i < n; ++i) {
            scanf("%d%d", &ranges[i].first, &ranges[i].second);
            all[nn++] = ranges[i].first;
            all[nn++] = ranges[i].second;
        }
        sort(all, all + nn);
        mm = unique(all, all + nn) - all;
        for(int i = 0; i < n; ++i) {
            int ul = lower_bound(all, all + mm, ranges[i].first) - all;
            int ur = lower_bound(all, all + mm, ranges[i].second) - all;
            update(ul, ur, i + 1);
        }
        ans.clear();
        query(0, mm - 1);
        printf("%d\n", ans.size());
    }
    return 0;
}

附录一

　　线段树维护点信息时，离散化会带来上述问题，把原来不连续的点变的连续。那么，解决办法就是，在有序的离散化数组中，在值相差大于1的两个相邻元素之间加入一个数，这个数的数值和位置都介于两个相邻元素之间，数值直接取为小数字+1即可。举个例子：对于[1, 10]，[1, 4]，[6, 10]这种样例，对应的有序的离散化数组是：{1, 4, 6, 10}，那么，在<1, 4>，<4, 6>，<6, 10>之间加入一个数字，再排序，得到新的有序的离散化数组：{1, 2, 4, 5, 6, 7, 10}。做区间修改时，[1, 4]区间被离散化成[1, 3]（下标从1开始），[6, 10]区间被离散化成[5, 7]，原来4和6不相邻，现在也不相邻，所以，做查询时就不会受离散化影响了。而如果是[1, 10]，[1, 4]，[5, 10]这种样例，对应的有序的离散化数组是：{1, 4, 5, 10}，在<1, 4>，<5, 10>之间加入一个数字，再排序，得到新的有序的离散化数组：{1, 2, 4, 5, 6, 10}。原本4和5是连续的，现在还是，所以，查询结果仍然不会受离散化影响。因此，离散化带来的问题就这么愉快地解决了。

　　另外，加入元素时，只需要在数组末尾添加新元素，然后再排下序就OK了。没必要用链表啥的去模拟。吃力不讨好。

转载于:https://www.cnblogs.com/fuzhihong0917/p/7704142.html