洛谷P5490扫描线

0是最小的数字,将一个线段看成一个区间,对于一个矩形,从下扫到上,入边为1,而出边为-1,意思是将这个区间上的所有点加1(区间修改).把线段表示为Line[i],其中记录了l,r,h,tag,左右端点,高度,入边还是出边(1或-1)

那么每次区间修改后不为0的区间它的值可能是1,2,3或者是其它数字,这不好统计,可以将它转化一下,0是不是表示没有被覆盖过的地方,我们只要统计0的个数然后用总长减去0的个数是不是就是现在线段所覆盖过的长度?

对于1e9的数据范围,我们首先需要离散化,例如题中给的样例将所有的x坐标拿出来排序100,150,200,250.离散化以后得到0,1,2,3.我们将这个离散化映射表用map表示map[0]=100,map[1]=150......

建立一个总长为3的线段树,那么节点[0,1)看做是线段[0,1],节点[1,2)看做线段[1,2]以此类推.

那么一个节点需要记录以下信息

0和0的长度->mn,cnt

考虑使用单点修改初始化,将[0,1)节点的cnt初始化为map[1]-map[0].

记得初始化高度为第一条线段的高度,首先查询0的个数,然后计算答案(第一次不起任何作用)=(高度*(总长-0的个数))=(Line[i].h-h)*(map[k-1]-map[0]-rangeQuery(0,k-1).cnt),然后区间修改,将该区间所有数+1,rangeApply(Line[i].l,Line[i].r,{Line[i].tag});

最终就可以得出答案了.

下面列举出来的线段树板子会执行懒标记线段树的功能,你只需要将节点信息Info,懒标记Tag,和+operator写好就行.

我使用的离散化思路是排序,去重二分查找,map作为一个映射表,二分查找的目的是为了将Line[i]中记录的左右端点换成映射值.

using ll = long long;
using i64 = long long;
template
struct LazySegmentTree {
    int n;
    std::vector info;
    std::vector tag;
    LazySegmentTree() : n(0) {}
    LazySegmentTree(int n_, Info v_ = Info()) {
        init(n_, v_);
    }
    template
    LazySegmentTree(std::vector init_) {
        init(init_);
    }
    void init(int n_, Info v_ = Info()) {
        init(std::vector(n_, v_));
    }
    template
    void init(std::vector init_) {
        n = init_.size();
        info.assign(4 << (int)std::log2(n), Info());
        tag.assign(4 << (int)std::log2(n), Tag());
        std::function build = [&](int p, int l, int r) {
            if (r - l == 1) {
                info[p] = init_[l];
                return;
            }
            int m = (l + r) / 2;
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p);
        };
        build(1, 0, n);
    }
    void pull(int p) {
        info[p] = info[2 * p] + info[2 * p + 1];
    }
    void apply(int p, const Tag& v) {
        info[p].apply(v);
        tag[p].apply(v);
    }
    void push(int p) {
        apply(2 * p, tag[p]);
        apply(2 * p + 1, tag[p]);
        tag[p] = Tag();
    }
    void modify(int p, int l, int r, int x, const Info& v) {
        if (r - l == 1) {
            info[p] = v;
            return;
        }
        int m = (l + r) / 2;
        push(p);
        if (x < m) {
            modify(2 * p, l, m, x, v);
        }
        else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p);
    }
    void modify(int p, const Info& v) {
        modify(1, 0, n, p, v);
    }
    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return info[p];
        }
        int m = (l + r) / 2;
        push(p);
        return rangeQuery(2 * p, l, m, x, y) + rangeQuery(2 * p + 1, m, r, x, y);
    }
    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }
    void rangeApply(int p, int l, int r, int x, int y, const Tag& v) {
        if (l >= y || r <= x) {
            return;
        }
        if (l >= x && r <= y) {
            apply(p, v);
            return;
        }
        int m = (l + r) / 2;
        push(p);
        rangeApply(2 * p, l, m, x, y, v);
        rangeApply(2 * p + 1, m, r, x, y, v);
        pull(p);
    }
    void rangeApply(int l, int r, const Tag& v) {
        return rangeApply(1, 0, n, l, r, v);
    }
    
};
struct Line {
    ll l, r, h, tag;
};
struct Tag
{
    i64 p;
    void apply(const Tag& t) { 
        p += t.p; 
    }
};
struct Info
{
    i64 mn,cnt = 0;
    void apply(const Tag& t) {
        mn += t.p; 
    }
};
Info operator+(const Info &a,const Info& b)
{
    Info res = { std::min(a.mn, b.mn), 0 };
    if (a.mn == res.mn) res.cnt += a.cnt;
    if (b.mn == res.mn) res.cnt += b.cnt;
    return res;
}

void solve() {
    int n;
    std::cin >> n;
    std::vector line(2 * n);
    std::vector map(2 * n);
    for (int i = 0; i < n; i++) {
        ll x1, y1, x2, y2;
        std::cin >> x1 >> y1 >> x2 >> y2;
        line[i] = { x1, x2, y1, 1 };  // 下边，权值为1
        line[i + n] = { x1, x2, y2, -1 };  // 上边，权值为-1
        map[i] = x1;
        map[i + n] = x2;
    }

    std::sort(line.begin(), line.end(), [&](Line x, Line y) {
        return x.h < y.h;
        });
    std::sort(map.begin(), map.end());
    
    for (int i = 2 * n - 1; i > 0; i--) {
        if (map[i] == map[i - 1])map.erase(map.begin() + i);
    }
    auto search = [&](int l, int r, int x) {
        while (l + 1 < r) {
            int mid = (l + r) / 2;
            if (map[mid] > x)r = mid;
            else l = mid;
        }
        return l;
    };
    int k = map.size();
    for (int i = 0; i < 2 * n; i++) {
        line[i].l = search(-1, k, line[i].l);
        line[i].r = search(-1, k, line[i].r);
    }
    LazySegmentTree tree(k);
    for (int i = 0; i < k - 1; i++) {
        tree.modify(i,{0, map[i+1] - map[i] });
    }
    //0,1,2,3
    ll ans = 0, h = line[0].h;
    for (int i = 0; i < 2 * n; i++) {
        Info res = tree.rangeQuery(0, k-1);

        if (res.mn == 0) {
            ans += (line[i].h - h) * (map[k-1] - res.cnt-map[0]);
        }
        h = line[i].h;
        tree.rangeApply(line[i].l, line[i].r, { line[i].tag });  // 更新区间

    }

    std::cout << ans << "\n";
}
int main() {
    std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    int t=1;
    //std::cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}