• 【转】POJ 1177 (线段树+离散化+扫描线) 详解


    摘要: POJ 1177 (线段树+离散化+扫描线),题目链接为http://poj.org/problem?id=1177在做本题之前,必须先了解什么是线段树和离散化,请看前一篇博文线段树(segment tree),里面对线段树和离散化的说明相对比较清楚了。对 ...

     

    POJ 1177 (线段树+离散化+扫描线),题目链接为http://poj.org/problem?id=1177

    在做本题之前,必须先了解什么是线段树和离散化,请看前一篇博文线段树(segment tree),里面对线段树和离散化的说明相对比较清楚了。

    对于这题,我们的思路步骤如下(代码和下面的文字解释结合着看):

    1.对于输入的N个矩形,有2*N条纵向边,我们把这些边叫做扫描线

    2.建立一个struct ScanLine,保留这些扫描线

    struct ScanLine{  int x;//横坐标  int y1;//扫描线的下端点  int y2;//扫描线的上端点  int flag;//若该扫描线属于矩形的左边的竖边,如AB,则叫做入边,值为1,若属于矩形的右边的竖边,如CD,则叫做出边,值为0};

    3.建立数组struct ScanLine scan[LEN];保存输入值,同时用y[LEN]保存所有的纵向坐标

    4.对scan数组进行排序,即所有竖边从左往右排序;对y排序并去除重复值,然后离散化,建立线段树。(PS:线段树的node[i].left和node[i].right保存的都是离散化的值,y[node[i].left]和y[node[i].right]保存的就是实际值,这个在代码中很容易理解)

    线段树节点struct Node

    struct Node{  int left;  int right;  int count;//被覆盖次数  int line;//所包含的区间数量,如三条[1,2],[2,3],[4,5]线段被覆盖,则line=2,因为 [1,2],[2,3]是连续的。这个是用来辅助计算横边的,如图,在AB和EG之间的横边AK和BL,它们是边界,line=1,|AB|+|EG|=2*line*|AB|  int lbd;//左端点是否被覆盖,用来辅助对line的计算  int rbd;//右端点是否被覆盖,用来辅助对line的计算  int m;//测度,即覆盖的区间长度,如[2,8]就为6};

    好的,上面建立了大的框架,然后就开始扫描了。

    1.将排序后的scan数组依次输入,执行插入线段insert函数(为入边)或者remove函数(为出边),同时更新m和line

    2.没扫描一次,就要计算一次周长perimeter,这里我们以图中的例子来讲解过程:

       首先是AB,它被插入线段树,perimeter = perimeter + |AB|;

       然后是EG,它被插入线段树,此时线段树的root节点的测度为|EG|的值,但由于之前之前加过|AB|,因而应该减去|AB|,其实就是减去|KL|,然后再加上line*2*|AK|,这里的line的值是未插入EG时线段树的根节点的line值。

    具体代码如下:

    #include <stdio.h>
    #include"iostream"
    #include <algorithm>
    #define LEN 10000
    using namespace std;
    struct Node{//Y方向
    int left;
    int right;
    int count;//被覆盖次数
    int line;//所包含的区间数量,如三条[1,2],[2,3],[4,5]线段被覆盖,则line=2,(Y方向)
    //因为 [1,2],[2,3]是连续的。这个是用来辅助计算横边的,如图,
    //在AB和EG之间的横边AK和BL,它们是边界,line=1,|AB|+|EG|=2*line*|AB|
    int lbd;//左端点是否被覆盖,用来辅助对line的计算
    int rbd;//右端点是否被覆盖,用来辅助对line的计算
    int m;//测度,即覆盖的区间长度,如[2,8]就为6(Y方向)
    };
    //对于输入的N个矩形,有2*N条纵向边,我们把这些边叫做扫描线建立一个struct ScanLine,保留这些扫描线
    struct ScanLine{
    int x;//横坐标
    int y1;//扫描线的下端点
    int y2;//扫描线的上端点
    int flag;//若该扫描线属于矩形的左边的竖边,如AB,则叫做入边,值为1
    //若属于矩形的右边的竖边,如CD,则叫做出边,值为0
    };
    struct Node node[LEN*4];
    struct ScanLine scan[LEN];//建立数组struct ScanLine scan[LEN]保存输入值
    int y[LEN];//用y[LEN]保存所有的纵向坐标
    void build(int l, int r, int i){//采用数组保存建立线段树(l,r为Y方向离散出来的点),也可以利用指针
    node[i].left = l;
    node[i].right = r;
    node[i].count = 0;
    node[i].m = 0;
    node[i].line = 0;
    if (r - l > 1){//递归建立线段树
    int middle = (l + r)/2;
    build(l, middle, 2*i + 1);
    build(middle, r, 2*i + 2);
    }
    }
    //更新测度m
    void update_m(int i)
    {
    if (node[i].count > 0)//node[i]被覆盖
    node[i].m = y[node[i].right] - y[node[i].left];
    else if (node[i].right - node[i].left == 1)//node[i]未被覆盖,到达叶节点
    node[i].m = 0;
    else{//node[i]被覆盖,未到达叶节点
    node[i].m = node[2*i + 1].m + node[2*i + 2].m;
    }
    }
    //更新line
    void update_line(int i){
    if (node[i].count > 0)//node[i]被覆盖
    {
    node[i].lbd = 1;
    node[i].rbd = 1;
    node[i].line = 1;
    }
    else if (node[i].right - node[i].left == 1)//node[i]未被覆盖,到达叶节点
    {
    node[i].lbd = 0;
    node[i].rbd = 0;
    node[i].line = 0;
    }
    else//node[i]被覆盖,未到达叶节点
    {
    node[i].lbd = node[2*i + 1].lbd;//左子树
    node[i].rbd = node[2*i + 2].rbd;//右子树
    //当左右端点都被覆盖,line减去1
    node[i].line = node[2*i + 1].line + node[2*i + 2].line - node[2*i + 1].rbd*node[2*i + 2].lbd;
    }
    }
    //注意,count在insert和remove中的变化分析参照文章“【转】线段树(segment tree)”
    void insert(int l, int r, int i){//此处l,r为离散化前Y方向的值
    //在这里要利用y[node[i]]取出node[i]离散化之前的值跟l和r进行比较 
    if (y[node[i].left] >= l && y[node[i].right] <= r)//node[i]被[l,r]覆盖
    (node[i].count)++;
    else if (node[i].right - node[i].left == 1)//node[i]未被[l,r]覆盖,到达叶节点
    return;
    else//node[i]未被[l,r]覆盖,未到达叶节点
    {
    int middle = (node[i].left + node[i].right)/2;
    if (r <= y[middle])
    insert(l, r, 2*i + 1);
    else if (l >= y[middle])
    insert(l, r, 2*i + 2);
    else
    {
    insert(l, y[middle], 2*i + 1);
    insert(y[middle], r, 2*i + 2);
    }
    }
    //更新当前Y方向度m和线段数line
    update_m(i);
    update_line(i);
    }
    void remove(int l, int r, int i){
    //在这里要利用y[node[i]]取出node[i]离散化之前的值跟l和r进行比较 
    if (y[node[i].left] >= l && y[node[i].right] <= r)//node[i]被[l,r]覆盖
    (node[i].count)--;
    else if (node[i].right - node[i].left == 1)//node[i]未被[l,r]覆盖,到达叶节点
    return;
    else//node[i]未被[l,r]覆盖,未到达叶节点
    {
    int middle = (node[i].left + node[i].right)/2;
    if (r <= y[middle])
    remove(l, r, 2*i + 1);
    else if (l >= y[middle])
    remove(l, r, 2*i + 2);
    else
    {
    remove(l, y[middle], 2*i + 1);
    remove(y[middle], r, 2*i + 2);
    }
    }
    update_m(i);
    update_line(i);
    }

    bool cmp(struct ScanLine line1, struct ScanLine line2)
    {
    if (line1.x == line2.x)
    return line1.flag > line2.flag; //若x相等,按照flag从高到低排序(先入边后出边)
    return (line1.x < line2.x); //否则,按照x从低到高排序
    }

    /*
    1.将排序后的scan数组依次输入,执行插入线段insert函数(为入边)或者remove函数(为出边),同时更新m和line
    2.每扫描一次,就要计算一次周长perimeter,这里我们以图中的例子来讲解过程:
    首先是AB,它被插入线段树,perimeter = perimeter + |AB|;
    然后是EG,它被插入线段树,此时线段树的root节点的测度为|EG|的值,但由于之前加过|AB|,因而应该减去|AB|,其实就是减去|KL|,然后再加上line*2*|AK|,这里的line的值是未插入EG时线段树的根节点的line值。
    */
    int main()
    {
    int n;
    scanf("%d", &n);
    int x1, y1, x2, y2;
    int i = 0;
    while(n--)
    {
    scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
    scan[i].x = x1;
    scan[i].y1 = y1;
    scan[i].y2 = y2;
    scan[i].flag = 1;//标记为入边
    y[i++] = y1;

    scan[i].x = x2;
    scan[i].y1 = y1;
    scan[i].y2 = y2;
    scan[i].flag = 0;//标记为出边
    y[i++] = y2;
    }
    /*
    对scan数组进行排序,即所有竖边从左往右排序;对y排序并去除重复值,然后离散化,建立线段树。
    (PS:线段树的node[i].left和node[i].right保存的都是离散化的值,
    y[node[i].left]和y[node[i].right]保存的就是实际值,这个在代码中很容易理解)
    */
    sort(scan, scan + i, cmp);

    //检测scan排序后的结果
    for(int ii=0;ii<i;ii++)
    cout<<scan[ii].x<<" ";
    cout<<endl;

    sort(y, y + i); 

    int unique_count = unique(y, y + i) - y; //y数组中不重复的个数

    build(0, unique_count - 1, 0); //离散化,建立线段树
    int perimeter = 0;
    int now_m = 0;
    int now_line = 0;
    for(int j=0;j<i;j++)
    {
    if (scan[j].flag)
    insert(scan[j].y1, scan[j].y2, 0);
    else
    remove(scan[j].y1, scan[j].y2, 0);


    perimeter += abs(node[0].m - now_m);//now_m是上一次的度,node[0]则是当前度;详见程序后图示,方便理解
    now_m = node[0].m; //根节点0的m值

    if (j >= 1) 
    perimeter += 2*now_line*(scan[j].x - scan[j-1].x); 
    now_line = node[0].line; //根节点0的line值
    }
    printf("%d\n", perimeter);
    system("pause");
    return 0;
    }

     

  • 相关阅读:
    负载均衡,分布式,集群的理解,多台服务器代码如何同步
    浅谈控制反转与依赖注入
    Jetbrains系列产品重置试用方法
    讲述一下一个还没毕业的科班程序猿的求职历程
    一个在求职路上挣扎的萌新
    用C#操作文件/文件夹(删除,复制,移动)
    随笔-关于公网IP无法访问服务器的解决办法
    C/s从文件(TXT)中读取数据插入数据库
    Sql Server + ADO.NET
    进程。线程与线程池
  • 原文地址:https://www.cnblogs.com/lzhitian/p/2596631.html
Copyright © 2020-2023  润新知