9-5 （线段树加扫描线）

扫描线
这类题目需要将一些操作排序,然后从左到右用一根扫描线(当然是在我们脑子里)扫过去
最典型的就是矩形面积并,周长并等题

hdu1542 Atlantis
题意:矩形面积并
思路:浮点数先要离散化;然后把矩形分成两条边,上边和下边,对横轴建树,然后从下到上扫描上去,用cnt表示该区间下边比上边多几个,sum代表该区间内被覆盖的线段的长度总和
这里线段树的一个结点并非是线段的一个端点,而是该端点和下一个端点间的线段,所以题目中r+1,r-1的地方可以自己好好的琢磨一下
线段树操作:update:区间增减 query:直接取根节点的值

#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int tot;
struct line{
    double x1, x2, y;
    int flag;
}l[3*maxn];
bool operator < (const line& a, const line& b) {return a.y<b.y;}
map<double, int> mark;
map<int, double> ID;
int cnt;
vector<double> vec;
int id(double a){
    if(!mark.count(a)) {
        mark[a] = ++cnt;
        ID[mark[a]] = a;
        //printf("id   %d %d %lf\n", mark[a], cnt-1, ID[mark[a]]);
    }
    return mark[a];
}
void cal(int num, double y, double x1, double x2, int f){
    l[num].y = y, l[num].x1 = x1, l[num].x2 = x2, l[num].flag = f;
}
struct Tree{
    int l, r;
    int c, lazy;
    double sum;
}tree[maxn*10];


void build(int node){
    tree[node].sum = tree[node].lazy = tree[node].c = 0;
    if(tree[node].l == tree[node].r) return;
    int mid = (tree[node].l + tree[node].r) / 2;
    tree[node*2].l = tree[node].l;
    tree[node*2].r = mid;
    tree[node*2+1].l = mid+1;
    tree[node*2+1].r = tree[node].r;
    build(node*2);
    build(node*2+1);
}

void pushdown(int node){
    if(tree[node].lazy){
        tree[node*2].c += tree[node].c;
        tree[node*2+1].c += tree[node].c;
        tree[node].lazy = 0;
    }
}

void update(int node, int s, int e, int f){
    //printf("  %d %d %d %d\n", node, s, e, f);
    int mid = (tree[node].l + tree[node].r) / 2;
    if(s <= tree[node].l && tree[node].r <= e){
        tree[node].lazy += f;
        tree[node].c += f;
        if(tree[node].c > 0) tree[node].sum = ID[tree[node].r]-ID[tree[node].l];
        else{
            if(tree[node].l == tree[node].r) tree[node].sum = 0;
            else {
                tree[node].sum = tree[node*2].sum + tree[node*2+1].sum;
                if(tree[node].lazy) tree[node].sum += ID[mid+1] - ID[mid];
            }
        }
        //printf("TER %d  %d  %f  %d  %d\n", tree[node].l, tree[node].r, tree[node].sum, node);
        return;
    }

    if(s <= mid && e > mid) tree[node].lazy += f;
    if(s <= mid) update(node*2, s, e, f);
    if(e > mid) update(node*2+1, s, e, f);
    if(tree[node].c == 0){
        tree[node].sum = tree[node*2].sum + tree[node*2+1].sum;
        if(tree[node].lazy) tree[node].sum += ID[mid+1] - ID[mid];
    } 
    else{
        tree[node].sum = ID[tree[node].r] - ID[tree[node].l];
    } 
    //printf("TER %d  %d  %f %d  %d\n", tree[node].l, tree[node].r, tree[node].sum, node);
    return;
}


int main(){
    //freopen("1.txt", "r", stdin);
    int n;
    int cas = 0;
    while(scanf("%d", &n) && n){
        cnt = tot = 0;
        mark.clear();
        vec.clear();
        ID.clear();
        for(int i = 0; i < n; i++){
            double x1, x2, y1, y2;
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            vec.push_back(x1);
            vec.push_back(x2);
            cal(tot++, y1, x1, x2, 1);
            cal(tot++, y2, x1, x2, -1);
        }
        sort(l, l+tot);
        sort(vec.begin(), vec.end());
        for(int i = 0; i < vec.size(); i++) id(vec[i]);
        tree[1].l = 1, tree[1].r=cnt;
        build(1);
        double sum = 0, h = l[0].y;
        for(int i = 0; i < tot; i++){
            sum += tree[1].sum * (l[i].y - h);
            update(1, mark[l[i].x1], mark[l[i].x2], l[i].flag);
        //    printf("    %f  %f  %f  %f  %f  %d\n", sum, tree[1].sum, l[i].x1, l[i].x2, h, l[i].flag);
            h = l[i].y;
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n", ++cas, sum);
    }
    return 0;
}

hdu1828 Picture
题意:矩形周长并
思路:与面积不同的地方是还要记录竖的边有几个(numseg记录),并且当边界重合的时候需要合并(用lbd和rbd表示边界来辅助)
线段树操作:update:区间增减 query:直接取根节点的值

这还是不知道为什么WA的版本，难过

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
struct line{
    int h, l, r;
    int flag;
}x[maxn*3], y[maxn*3];
bool operator < (const line& a, const line& b){
    return a.h<b.h;
}
struct Tree{
    int l, r, sum;
    int lazy, c;
}tree[maxn*10];
vector<int> vecx, vecy;
map<int, int> id, id_find;
int cntx, cnty;
void Insert(line l[], int n, int h, int ll, int r, int f){
    l[n].h = h, l[n].l = ll, l[n].r = r;
    l[n].flag = f;
}

int init(vector<int>& vec){
    int tot = 0;
    id.clear();
    id_find.clear();
    for(int i = 0; i < vec.size(); i++){
        if(!id.count(vec[i])){
            id[vec[i]] = ++tot;
            id_find[tot] = vec[i];
        }
    }
    return tot;
}

void update(int node, int s, int e, int f){
    if(s <= tree[node].l && tree[node].r <= e){
        tree[node].lazy += f;
        tree[node].c += f;
        if(tree[node].c > 0) tree[node].sum = id_find[tree[node].r] - id_find[tree[node].l];
        else if(tree[node].l == tree[node].r)  tree[node].sum = 0;
        else{
            tree[node].sum = tree[node*2].sum + tree[node*2+1].sum;
            if(tree[node].lazy) tree[node].sum += id_find[tree[node*2+1].l] - id_find[tree[node*2].r];
        }
        return;
    }

    int mid = (tree[node].l + tree[node].r) / 2;
    if(s <= mid && e > mid) tree[node].lazy += f;
    if(s <= mid) update(node*2, s, e, f);
    if(e > mid) update(node*2+1, s, e, f);
    if(tree[node].c) tree[node].sum = id_find[tree[node].r] - id_find[tree[node].l];
    else{
        tree[node].sum = tree[node*2].sum + tree[node*2+1].sum;
        if(tree[node].lazy) tree[node].sum += id_find[tree[node*2+1].l] - id_find[tree[node*2].r];
    }

    return;
}

void build(int node){
    tree[node].sum = tree[node].lazy = tree[node].c = 0;
    if(tree[node].l == tree[node].r) return;
    int mid = (tree[node].l + tree[node].r) / 2;
    tree[node*2].l = tree[node].l;
    tree[node*2].r = mid;
    tree[node*2+1].l = mid+1;
    tree[node*2+1].r = tree[node].r;
    build(node*2);
    build(node*2+1);
}

void solve(line l[], int tot, int cnt, long long& ans){
    tree[1].l = 1, tree[1].r = tot;
    build(1);
    int pre = 0;
    for(int i = 0; i < cnt; i++){
        update(1, id[l[i].l], id[l[i].r], l[i].flag);
        ans += abs(tree[1].sum - pre);
        pre = tree[1].sum;
    }
}

int main()
{
    int n;
    while(~scanf("%d", &n)){
        cntx = cnty = 0;
        vecx.clear(), vecy.clear();
        for(int i = 0; i < n; i++){
            int x1, y1, x2, y2;
            scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
            Insert(x, cntx++, y1, x1, x2, 1);
            Insert(x, cntx++, y2, x1, x2, -1);
            Insert(y, cnty++, x1, y1, y2, 1);
            Insert(y, cnty++, x2, y1, y2, -1);
            vecx.push_back(x1), vecx.push_back(x2);
            vecy.push_back(y1), vecy.push_back(y2);
        }
        sort(vecx.begin(), vecx.end());
        sort(vecy.begin(), vecy.end());
        sort(x, x+cntx);
        sort(y, y+cnty);
        long long ans = 0, tot;
        tot = init(vecx);
        solve(x, tot, cntx, ans);
        tot = init(vecy);
        solve(y, tot, cnty, ans);
        printf("%lld\n", ans);
    }
    return 0;
}