【POJ3470】Walls（线段树）（扫描线）

最新推荐文章于 2020-01-27 17:27:21 发布
最新推荐文章于 2020-01-27 17:27:21 发布
阅读量664 收藏
点赞数 1
分类专栏： OI题解 文章标签： poj 扫描线 线段树 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/can919/article/details/76339105
版权

题目大意

本义

有n堵墙，m只智障鸟，给出墙端点坐标，鸟坐标，墙一定是平行于坐标轴，横着或竖着，每只鸟都会选一个离自己最近的墙撞过去，鸟一定是平行于坐标轴飞行，只能横着或竖着飞，问每堵墙被几只鸟撞过。

题目没说的坑爹问题：
  • 坐标可以为负数
  • 坐标可能大于INT_MAX
  • 鸟可能初始就卡在某堵墙里（坐标在墙的端点或连线上，给这堵墙算一次）
  • 鸟可以在墙的延长线上，可以直接顺着延长线撞到墙上
  • 鸟不会有多个墙来选择
  • 鸟有可能撞不到任何墙

题解

扫描线，从左往右时，视为鸟固定往左飞，用线段树记录这根扫描线遇到的墙，标记墙的领土，如下图。
扫描线
灰色的扫描线向右扫描，扫描线上标有颜色的是线段树标记的墙的领土，如果此时碰到鸟，则鸟一直向右飞碰到的墙可直接用线段树查询。如马上碰到右边的黑点，查询线段树，就可得知它将撞到红色墙。继续扫描过程中，碰到黄色墙，将在对应线段树区域标为黄色，然后灰色点就可以撞到黄色墙。注意，横着的绿色墙也需要标记，在线段树上那一个点被标为绿色。
具体实现细节见代码，有注释。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=200010;
struct Bird
{
    int id;
    long long x,y;
    inline void read()
    {scanf("%lld%lld",&x,&y);}
};
bool Bird_cmpx_g(Bird a,Bird b)
{return a.x<b.x||(a.x==b.x&&a.y<b.y);}
bool Bird_cmpy_g(Bird a,Bird b)
{return a.y<b.y||(a.y==b.y&&a.x<b.x);}
bool Bird_cmpx_l(Bird a,Bird b)
{return a.x>b.x||(a.x==b.x&&a.y>b.y);}
bool Bird_cmpy_l(Bird a,Bird b)
{return a.y>b.y||(a.y==b.y&&a.x>b.x);}
struct Wall
{
    int id;
    Bird a,b;
    inline void read()
    {a.read();b.read();}
    inline bool mode()
    {return a.x==b.x;}
};
bool Wall_cmpx_g(Wall a,Wall b)
{return Bird_cmpx_g(a.a,b.a);}
bool Wall_cmpy_g(Wall a,Wall b)
{return Bird_cmpy_g(a.a,b.a);}
bool Wall_cmpx_l(Wall a,Wall b)
{return Bird_cmpx_l(a.a,b.a);}
bool Wall_cmpy_l(Wall a,Wall b)
{return Bird_cmpy_l(a.a,b.a);}
class SegTree
{
    static int N;
    int wid[MAXN*12];
public:
    inline void Init(int n)
    {
        memset(wid,0,sizeof wid);
        N=n;
    }
    void Insert(int L,int R,int val,int id=1,int l=0,int r=N)
    {
        if(r<L||R<l)
            return;
        if(L<=l&&r<=R)
        {
            wid[id]=val;
            return;
        }
        if(wid[id]!=-1)
            wid[id*2]=wid[id*2+1]=wid[id];
        Insert(L,R,val,id*2,l,(l+r)/2);
        Insert(L,R,val,id*2+1,(l+r)/2+1,r);
        if(wid[id*2]==-1||wid[id*2+1]==-1||wid[id*2]!=wid[id*2+1])
            wid[id]=-1;
    }
    int Query(int pos,int id=1,int l=0,int r=N)
    {
        if(r<pos||pos<l)
            return -1;
        if(wid[id]!=-1)
            return wid[id];
        int q1=Query(pos,id*2,l,(l+r)/2);
        int q2=Query(pos,id*2+1,(l+r)/2+1,r);
        if(q1==-1)return q2;
        return q1;
    }
};
Wall wall[MAXN];
Bird bird[MAXN];
long long mapx[MAXN*3],mapy[MAXN*3];
int x_cnt,y_cnt;
long long dis[MAXN];
int ans[MAXN],hitid[MAXN];
SegTree ST;
int SegTree::N;
int main()
{
    int N,M;
    scanf("%d%d",&N,&M);
    //输入，初始化，记录x，y，用于离散化
    for(int i=1;i<=N;i++)
    {
        wall[i].read();
        wall[i].id=i;
        mapx[x_cnt++]=wall[i].a.x;
        mapx[x_cnt++]=wall[i].b.x;
        mapy[y_cnt++]=wall[i].a.y;
        mapy[y_cnt++]=wall[i].b.y;
    }
    for(int i=1;i<=M;i++)
    {
        bird[i].read();
        bird[i].id=i;
        mapx[x_cnt++]=bird[i].x;
        mapy[y_cnt++]=bird[i].y;
    }
    memset(dis,0x7F,sizeof dis);
    //排序，离散化墙，鸟的坐标
    sort(mapx,mapx+x_cnt);
    sort(mapy,mapy+y_cnt);
    for(int i=1;i<=N;i++)
    {
        wall[i].a.x=lower_bound(mapx,mapx+x_cnt,wall[i].a.x)-mapx;
        wall[i].a.y=lower_bound(mapy,mapy+y_cnt,wall[i].a.y)-mapy;
        wall[i].b.x=lower_bound(mapx,mapx+x_cnt,wall[i].b.x)-mapx;
        wall[i].b.y=lower_bound(mapy,mapy+y_cnt,wall[i].b.y)-mapy;
    }
    for(int i=1;i<=M;i++)
    {
        bird[i].x=lower_bound(mapx,mapx+x_cnt,bird[i].x)-mapx;
        bird[i].y=lower_bound(mapy,mapy+y_cnt,bird[i].y)-mapy;
    }
    int wid,bid;
    //设置墙同一直线总是坐标小的在前，方便排序
    for(int i=1;i<=N;i++)
    {
        if(wall[i].mode()&&wall[i].a.y>wall[i].b.y)
            swap(wall[i].a.y,wall[i].b.y);
        if(!wall[i].mode()&&wall[i].a.x>wall[i].b.x)
            swap(wall[i].a.x,wall[i].b.x);
    }
    //初始化，按x从小到大排序
    wid=bid=1;
    ST.Init(3*N);
    sort(wall+1,wall+N+1,Wall_cmpx_g);
    sort(bird+1,bird+M+1,Bird_cmpx_g);
    //扫描线，从左到右，从下到上，鸟向左撞
    while(wid<=N||bid<=M)
    {
        //添加墙的地盘
        if(wid<=N&&(bid>M||Bird_cmpx_g(wall[wid].a,bird[bid])))
        {
            ST.Insert(wall[wid].a.y,wall[wid].b.y,wid);
            wid++;
        }
        //更新鸟的答案
        else if(bid<=M)
        {
            int qid=ST.Query(bird[bid].y);
            if(qid!=0)
            {
                long long d=max(0LL,mapx[bird[bid].x]-mapx[wall[qid].b.x]);
                if(d<dis[bird[bid].id])
                {
                    if(dis[bird[bid].id]!=0x7F7F7F7F7F7F7F7FLL)
                        ans[hitid[bird[bid].id]]--;
                    ans[wall[qid].id]++;
                    dis[bird[bid].id]=d;
                    hitid[bird[bid].id]=wall[qid].id;
                }
            }
            bid++;
        }
    }
    //初始化，按y从小到大排序
    wid=bid=1;
    ST.Init(3*N);
    sort(wall+1,wall+N+1,Wall_cmpy_g);
    sort(bird+1,bird+M+1,Bird_cmpy_g);
    //扫描线，从下到上，从左到右，鸟向下撞
    while(wid<=N||bid<=M)
    {
        //添加墙的地盘
        if(wid<=N&&(bid>M||Bird_cmpy_g(wall[wid].a,bird[bid])))
        {
            ST.Insert(wall[wid].a.x,wall[wid].b.x,wid);
            wid++;
        }
        //更新鸟的答案
        else if(bid<=M)
        {
            int qid=ST.Query(bird[bid].x);
            if(qid!=0)
            {
                long long d=max(0LL,mapy[bird[bid].y]-mapy[wall[qid].b.y]);
                if(d<dis[bird[bid].id])
                {
                    if(dis[bird[bid].id]!=0x7F7F7F7F7F7F7F7FLL)
                        ans[hitid[bird[bid].id]]--;
                    ans[wall[qid].id]++;
                    dis[bird[bid].id]=d;
                    hitid[bird[bid].id]=wall[qid].id;
                }
            }
            bid++;
        }
    }
    //设置墙同一直线总是坐标大的在前，方便排序
    for(int i=1;i<=N;i++)
    {
        if(wall[i].mode()&&wall[i].a.y<wall[i].b.y)
            swap(wall[i].a.y,wall[i].b.y);
        if(!wall[i].mode()&&wall[i].a.x<wall[i].b.x)
            swap(wall[i].a.x,wall[i].b.x);
    }
    //初始化，按x从大到小排序
    wid=bid=1;
    ST.Init(3*N);
    sort(wall+1,wall+N+1,Wall_cmpx_l);
    sort(bird+1,bird+M+1,Bird_cmpx_l);
    //扫描线，从右到左，从上到下，鸟向右撞
    while(wid<=N||bid<=M)
    {
        //添加墙的地盘
        if(wid<=N&&(bid>M||Bird_cmpx_l(wall[wid].a,bird[bid])))
        {
            ST.Insert(wall[wid].b.y,wall[wid].a.y,wid);
            wid++;
        }
        //更新鸟的答案
        else if(bid<=M)
        {
            int qid=ST.Query(bird[bid].y);
            if(qid!=0)
            {
                long long d=max(0LL,mapx[wall[qid].b.x]-mapx[bird[bid].x]);
                if(d<dis[bird[bid].id])
                {
                    if(dis[bird[bid].id]!=0x7F7F7F7F7F7F7F7FLL)
                        ans[hitid[bird[bid].id]]--;
                    ans[wall[qid].id]++;
                    dis[bird[bid].id]=d;
                    hitid[bird[bid].id]=wall[qid].id;
                }
            }
            bid++;
        }
    }
    //初始化，按y从大到小排序
    wid=bid=1;
    ST.Init(3*N);
    sort(wall+1,wall+N+1,Wall_cmpy_l);
    sort(bird+1,bird+M+1,Bird_cmpy_l);
    //扫描线，从上到下，从右到左，鸟向下撞
    while(wid<=N||bid<=M)
    {
        //添加墙的地盘
        if(wid<=N&&(bid>M||Bird_cmpy_l(wall[wid].a,bird[bid])))
        {
            ST.Insert(wall[wid].b.x,wall[wid].a.x,wid);
            wid++;
        }
        //更新鸟的答案
        else if(bid<=M)
        {
            int qid=ST.Query(bird[bid].x);
            if(qid!=0)
            {
                long long d=max(0LL,mapy[wall[qid].b.y]-mapy[bird[bid].y]);
                if(d<dis[bird[bid].id])
                {
                    if(dis[bird[bid].id]!=0x7F7F7F7F7F7F7F7FLL)
                        ans[hitid[bird[bid].id]]--;
                    ans[wall[qid].id]++;
                    dis[bird[bid].id]=d;
                    hitid[bird[bid].id]=wall[qid].id;
                }
            }
            bid++;
        }
    }
    //输出
    for(int i=1;i<=N;i++)
        printf("%d\n",ans[i]);
    return 0;
}
CaptainHarryChen
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【刷题计划1】【poj分类转载】
loving coding
08-19 1149
----------------2018.4.10更新-----------------------原本这只是暑假刷题计划，后来因为某些原因，自己就不是很努力的刷题，现在情况有变，so，重新继续咯~下个月26号省赛，扣去中间实训的一周时间和几次校赛，大概只有一个月时间。目前计划是，每天基础算法题+cf上3题，专业课也先停了，自己这段时间只想认真写题。昨天晚上又失眠了，虽然我知道保证训练效率的关键是...
线段树练习POJ 3264
04-14
线段树是一种数据结构，常用于处理区间查询与更新的问题，它能高效地支持动态维护区间最值、求和等问题。在本题“POJ 3264”中，我们可能面临的是一个区间最值或者区间求和的计算任务。线段树的基本思想是将数组或...
POJ 3470 Walls（线段树+扫描线）
weixin_30344995的博客
01-23 151
【题目链接】http://poj.org/problem?id=3470 【题目大意】 　　给出几面墙，均垂直于x轴或者y轴，给出一些鸟的位置（二维坐标点）， 　　鸟只会垂直x轴或者y轴飞行，并且会撞上最近的墙，问每面墙最后会有几只鸟撞上去。 【题解】 　　我们将所有的二维坐标离散，对xy方向分别进行扫描线， 　　以y轴方向为例，我们先从y最小的线开始扫， ...
POJ 3470|Walls|线段树
とある黄鱼のOIブログ
04-27 1383
网格上有N(<=5e4)堵墙，有M(<=5e4)只鸟，其会选择最近的那堵墙撞晕，求鸟撞到各堵墙的次数。考试时给的中文翻译不忍直视。。貌似还是从某题解直接抄过来的。。直接看英文了。。 然后就在POJ上排#13了。。首先离散化一下。。 然后因为只能上下左右4个方向飞情况类似，这里我们只需要讨论一个方向。考虑向上飞的情况，我们人为添加一条下边界扫描，同时维护横着的墙，显然，如果遇到了新的墙，肯定目前其
POJ_3470 Walls 【离散化+扫描线+线段树】
weixin_30675247的博客
04-05 161
一、题面 POJ3470 二、分析 POJ感觉是真的老了。 这题需要一些预备知识：扫描线，离散化，线段树。线段树是解题的关键，因为这里充分利用了线段树区间修改的高效性，再加上一个单点查询。 为什么需要离散化？ 坐标太分散了，据说可以到 long long，但是就这么多个点，所以离散化一下，方便处理。 为什么用扫描线算法？ 用扫描线，可以方便的求出一个bird到wall的距离，因为是...
poj 3470 Walls
weixin_30527551的博客
05-31 125
Walls Time Limit: 6000MS ...
POJ-3470 Walls
EIP_silly的博客
01-27 311
POJ-3470 Walls Time Limit: 6000MS Memory Limit: 131072K Total Submissions: 2624 Accepted: 402 Case Time Limit: 3000MS Description There are N walls. A wall has an infinity height, so it looks like a...
POJ 试题分类
热门推荐
nike0good |Oier&ACMer | 熟能生巧
08-09 3万+
转载请注明出处：優YoUhttp://blog.csdn.net/lyy289065406/article/details/6642573 改革V1.0 ——刷题法则 恭祝Blog.cn开博2012.8.1 较初级: OJ上的一些水题(可用来练手和增加自信)  (poj1003,poj1004,poj1005,poj120
重走长征路---OI每周刷题记录——hzwer
mrcrack的博客
11-25 2万+
重走长征路---OI每周刷题记录——hzwer OI每周刷题记录——hzwer  原文地址http://hzwer.com/410.html 2015年6月15日 6月15日    2015 详见https://blog.csdn.net/mrcrack/article/details/87157602 Codeforces Round #158 (Div. 2) A.模拟 B.ma...
To Do List
白鸟
07-19 2073
RT
poj2823.cpp.tar.gz_线段树
09-20
在`poj2823.cpp`源代码中，我们可以看到实现线段树的具体细节，包括如何初始化、更新以及查询线段树。此外，代码可能还包括了问题的输入输出处理，错误检查，以及可能的优化策略，比如lazy propagation（惰性传播）...
POJ3277.rar_3277 poj_poj3277_多个面积_线段树
最新发布
09-24
标题中的“POJ3277.rar_3277 poj_poj3277_多个面积_线段树”是指一个与编程竞赛相关的压缩文件，特别提到了POJ（Problemset Online Judge）的第3277号问题。POJ是一个著名的在线编程竞赛平台，参与者需要解决各种...
poj 2352 stars（树状数组，线段树）
07-18
这是一道很不错的题目，即可以用线段树做也可以用树状数组，可谓经典。不过当然了线段树是比较难搞，而树状数组是极其简洁的，构造很简单，下面就分别来介绍一下两种方法...
线段树入门学习(二）(兼解POJ3468) JAVA
04-14
在本教程中，我们将深入探讨线段树的基本概念，以及如何使用Java实现线段树来解决实际问题，如POJ3468题目。 首先，理解线段树的核心在于它的分治思想。线段树将一个大区间（通常是一维数组）分成多个小区间，每个...
【CodeForces908D】New Year and Arbitrary Arrangement （期望DP）
CaptainChen的博客
12-31 1586
题目大意有一个ab字符串，初始为空。 用PaPa+Pb\frac {P_a} {P_a+P_b}的概率在末尾添加字母a，有 PbPa+Pb\frac {P_b} {P_a+P_b}的概率在末尾添加字母b，当出现≥k个ab子串时立即停止添加字母，求最后期望的ab子串个数。（子串ab不要求连续） 例子：当k=1，aab含2个ab，bbabbab时不可能出现的，因为到了bbab就会停止添加字母。
【CodeForces1019E】Raining season（边分治+斜率优化）
CaptainChen的博客
08-19 1276
题目大意 有n个结点的一棵树，每条边有两个权值a,b，第t天经过第i条边花费时间ait+bait+ba_it+b，给定m，求t=0,1,2...m−1t=0,1,2...m−1t=0,1,2...m-1时，最长的路径长度。 题解 简介边分治 类似点分治选择重心，边分治选择一条边，把树分成两边，使得两边的点数最接近。 但对普通的树进行边分治容易退化，如下面这种图会退化为O(n)O(n)O(...
排列问题（DP）
CaptainChen的博客
03-12 1178
题意 长度为N的排列是一个序列(a,a,...,a)(a,a,...,a)(a , a , ..., a )，恰好包含从111到NNN的每一个数字。例如，(3,1,4,5,2)(3,1,4,5,2)(3, 1, 4, 5, 2)是 一个长度为5的排列。 对于两个排列a和b，定义 magic(a,b)=max(a,b)+max(a,b)+...+max(a,b)magic(a,b)=max(...
【不明题目】正则表达式（栈的应用）
CaptainChen的博客
07-07 1159
题目：给定一个字符串S，判断其是否为合法的正则表达式一个正则表达式定义：（此正则表达式非正规） 0是正则表达式，1是正则表达式 P和Q是正则表达式，则PQ是正则表达式 P是正则表达式，则(P)是正则表达式 P是正则表达式，则P*是正则表达式 P和Q是正则表达式，则P|Q是正则表达式 输入样例：010101101* (11|0*)* )*111 #输出样例：YES YES NO题解：用一个栈
线段树扫描线法提升面积问题求解效率
线段树之扫描线是一种在信息学竞赛中常用的高级数据结构技术，主要用于解决涉及矩形区域的问题，如面积、周长计算，尤其是在矩形可能重叠的情况下。本资料主要介绍如何利用线段树结合扫描线算法来高效处理此类问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值