线！线！线！线段树

最新推荐文章于 2022-05-18 06:00:00 发布
最新推荐文章于 2022-05-18 06:00:00 发布
阅读量335 收藏
点赞数 1
分类专栏： ACM_新模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxy160/article/details/76682853
版权

终于学到线段树了，以前看见很多这样的题，然后暴力，然后TTTTTT了，，，，
我并不打算写了，不过我看到一个非常好的博客，推荐给初学者
http://www.cnblogs.com/TenosDoIt/p/3453089.html#a
特别好玩！！！
最简单的板子（建树，区间最小(大)值，区间和，单节点更新，区间更新）
这里写图片描述
以0为根节点表示的是整个区间，向左右分叉，左面是左区间，右面是右区间
然后重复以上过程直到查到单个数才回溯，从而变成如上图的样子。

/*****最值*****/
void change(int root,int x,int k)//单点修改
{
    int l=e[root].l;
    int r=e[root].r;
    int mid=(l+r)/2;
    if(l==r)
    {
        e[root].sum+=k;
        return ;
    }
    if(x<=mid)
        change(root<<1,x,k);
    else
        change(root<<1|1,x,k);
    e[root].sum=e[root<<1].sum+e[root<<1|1].sum;
}
int query(int root,int ql,int qr)//区间查询（求最值）
{
    int l=e[root].l,r=e[root].r;
    int mid=(l+r)/2;
    int ans=-1;
    if(ql<=l&&r<=qr)
    {
        return e[root].maxx;
    }
    if(ql<=mid)
        ans=max(ans,query(root<<1,ql,qr));
    if(mid<qr)
        ans=max(ans,query(root<<1|1,ql,qr));
    return ans;
}

/*****求和********/
void pushdown(int root)//求和更新
{
    if(e[root].flag)
    {
        int l=e[root].l,r=e[root].r;
        int mid=(l+r)/2;
        e[root<<1].sum+=(e[root].flag*(mid-l+1));
        e[root<<1].flag+=e[root].flag;//应该是+，易错
        e[root<<1|1].sum+=(e[root].flag*(r-mid));
        e[root<<1|1].flag+=e[root].flag;
        e[root].flag=0;
    }
}
int query(int root,int ql,int qr)//区间查询（求和）
{
    int l=e[root].l;
    int r=e[root].r;
    int mid=(l+r)/2;
    if(ql<=l&&r<=qr)
        return e[root].sum;
    int ans=0;
    pushdown(root);//看是否需要
    if(ql<=mid)
        ans+=query(root<<1,ql,qr);
    if(mid<qr)
        ans+=query(root<<1|1,ql,qr);
    return ans;
}
void update(int root,int ql,int qr,int k)//区间更新（求和）
{
    int l=e[root].l,r=e[root].r;
    int mid=(l+r)/2;
    if(ql<=l&&r<=qr)
    {
        e[root].sum+=k*(r-l+1);
        e[root].flag+=k;
        return ;
    }
    pushdown(root);
    if(ql<=mid)
        update(root<<1,ql,qr,k);
    if(mid<qr)
        update(root<<1|1,ql,qr,k);
    e[root].sum=e[root<<1].sum+e[root<<1|1].sum;//更新回溯
}
/******区间染色*****/
int ro[maxn];
int vis[maxn];
int ans;
void pushdown(int root)
{
    if(ro[root]!=-1)
    {
        ro[root<<1]=ro[root];
        ro[root<<1|1]=ro[root];
        ro[root]=-1;
    }
}
void update(int root,int l,int r,int ql,int qr,int k)
{
    if(ql<=l&&r<=qr)
    {
        ro[root]=k;
        return ;
    }
    pushdown(root);
    int mid=(l+r)/2;
    if(mid>=ql) update(root<<1,l,mid,ql,qr,k);
    if(mid<qr) update(root<<1|1,mid+1,r,ql,qr,k);
}
void query(int root,int l,int r)
{
    if(ro[root]!=-1)
    {
        int k=ro[root];
        if(!vis[k])
        {
            ans++;
            vis[k]=1;
        }
        return ;
    }
    if(l==r) return ;
    int mid=(l+r)/2;
    query(root<<1,l,mid);
    query(root<<1|1,mid+1,r);
}
int l[maxn],r[maxn];
int m[maxn];
int main()
{
    int t,n;
    scanf("%d",&t);
    while(t--)
    {
        memset(m,0,sizeof(m));
        memset(ro,-1,sizeof(ro));
        memset(vis,0,sizeof(vis));
        ans=0;
        int tot=0;
        scanf("%d",&n);
        for(int i=0;i<n;i++)
        {
            scanf("%d%d",&l[i],&r[i]);
            m[tot++]=l[i];
            m[tot++]=r[i];
        }
        sort(m,m+tot);
        tot=unique(m,m+tot)-m;
        //防止出现1 10，1 4，7 10这样的样例，所以才有下一步
        for(int i=tot-1;i>=1;i--)
        {
            if(m[i]-m[i-1]>1)
                m[tot++]=m[i-1]+1;
        }
        sort(m,m+tot);
        for(int i=0;i<n;i++)
        {
            int ll=lower_bound(m,m+tot,l[i])-m;
            int rr=lower_bound(m,m+tot,r[i])-m;
            update(1,1,tot,ll+1,rr+1,i+1);
        }
        query(1,1,tot);
        printf("%d\n",ans);
    }
    return 0;
}
/*****矩形并求总面积*****/
double x1,yy1,x2,y2;
double m[maxn];
struct node
{
    double l,r,h;
    int k;
} e[maxn];
int cmp(node x,node y)
{
    return x.h<y.h;
}
struct nodee
{
    int l,r,w;
    double len;
} tree[maxn];
void build(int root,int l,int r)
{
    tree[root].l=l,tree[root].r=r;
    tree[root].len=0.0,tree[root].w=0;
    if(l==r) return ;
    int mid=(l+r)/2;
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
}
void bac(int root)
{
    int l=tree[root].l-1,r=tree[root].r;//r不减1把缺失的区间找回来
    if(tree[root].w)
    {
        tree[root].len=m[r]-m[l];
    }
    else if(tree[root].l==tree[root].r)//注意
        tree[root].len=0;
    else
        tree[root].len=tree[root<<1].len+tree[root<<1|1].len;
}
void update(int root,int ql,int qr,int x)
{
    int l=tree[root].l,r=tree[root].r;
    if(ql<=l&&r<=qr)
    {
        tree[root].w+=x;
        bac(root);
        return ;
    }
    int mid=(l+r)/2;
    if(mid>=ql) update(root<<1,ql,qr,x);
    if(mid<qr) update(root<<1|1,ql,qr,x);
    bac(root);
}
int main()
{
    int n;
    int tt=1;
    while(~scanf("%d",&n)&&n)
    {
        int tot=0;
        for(int i=0; i<n; i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&yy1,&x2,&y2);
            e[tot].l=x1;
            e[tot].r=x2;
            e[tot].h=yy1;
            e[tot].k=1;
            m[tot++]=x1;

            e[tot].l=x1;
            e[tot].r=x2;
            e[tot].h=y2;
            e[tot].k=-1;
            m[tot++]=x2;
        }
        sort(e,e+tot,cmp);
        sort(m,m+tot);
        tot=unique(m,m+tot)-m;
        build(1,1,tot);
        double ans=0.0;
        for(int i=0; i<2*n-1; i++)
        {
            int ll=lower_bound(m,m+tot,e[i].l)-m;
            int rr=lower_bound(m,m+tot,e[i].r)-m;
            update(1,ll+1,rr,e[i].k);//rr不加1避免区间缺失
            ans+=(e[i+1].h-e[i].h)*tree[1].len;
        }
        printf("Test case #%d\n",tt++);
        printf("Total explored area: %.2lf\n\n",ans);
    }
    return 0;
}
/*****矩形并求叠加层数为2的*****/
double x1,yy1,x2,y2;
double m[maxn];
struct node
{
    double l,r,h;
    int k;
} e[maxn];
int cmp(node x,node y)
{
    return x.h<y.h;
}
struct nodee
{
    int l,r,w;
    double len,lenn;
} tree[maxn];
void build(int root,int l,int r)
{
    tree[root].l=l,tree[root].r=r;
    tree[root].len=0.0;
    tree[root].w=0;
    tree[root].lenn=0.0;
    if(l==r) return ;
    int mid=(l+r)/2;
    build(root<<1,l,mid);
    build(root<<1|1,mid+1,r);
}
void bac(int root)
{
    int l=tree[root].l-1,r=tree[root].r;//r不减1把缺失的区间找回来
    if(tree[root].w)
        tree[root].len=m[r]-m[l];
    else if(tree[root].l==tree[root].r)
        tree[root].len=0;
    else
        tree[root].len=tree[root<<1].len+tree[root<<1|1].len;

    if(tree[root].w>1)
        tree[root].lenn=m[r]-m[l];
    else if(tree[root].l==tree[root].r)
        tree[root].lenn=0;
    else if(tree[root].w==1)
        tree[root].lenn=tree[root<<1].len+tree[root<<1|1].len;
    else
        tree[root].lenn=tree[root<<1].lenn+tree[root<<1|1].lenn;
}
void update(int root,int ql,int qr,int x)
{
    int l=tree[root].l,r=tree[root].r;
    if(ql<=l&&r<=qr)
    {
        tree[root].w+=x;
        bac(root);
        return ;
    }
    int mid=(l+r)/2;
    if(mid>=ql) update(root<<1,ql,qr,x);
    if(mid<qr) update(root<<1|1,ql,qr,x);
    bac(root);
}
int main()
{
    int t,n;
    int tt=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(m,0,sizeof(m));
        int tot=0;
        for(int i=0; i<n; i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&yy1,&x2,&y2);
            e[tot].l=x1;
            e[tot].r=x2;
            e[tot].h=yy1;
            e[tot].k=1;
            m[tot++]=x1;

            e[tot].l=x1;
            e[tot].r=x2;
            e[tot].h=y2;
            e[tot].k=-1;
            m[tot++]=x2;
        }
        sort(e,e+tot,cmp);
        sort(m,m+tot);
        tot=unique(m,m+tot)-m;
        build(1,1,tot);
        double ans=0.0;
        for(int i=0; i<2*n-1; i++)
        {
            int ll=lower_bound(m,m+tot,e[i].l)-m;
            int rr=lower_bound(m,m+tot,e[i].r)-m;
            update(1,ll+1,rr,e[i].k);//rr不加1避免区间缺失
            ans+=(e[i+1].h-e[i].h)*tree[1].lenn;
        }
        printf("%.2lf\n",ans);
    }
    return 0;
}
zz你的名字
关注
专栏目录
线段树应用——扫描线
Lucas_FC_的博客
07-25 2314
扫描线（难的批爆）
线段树之扫描线（HDU-1542）
月巴虫丰博客
05-13 473
线段树之扫描线，主要是为了解决平面矩阵并以及空间立体交的问题。
扫描线（线段树）
Cauchy的博客
05-18 1921
文章目录扫描线扫描线求重叠矩形面积思路算法流程性质经典例题247. 亚特兰蒂斯 扫描线 线段树的一大应用是扫描线。 扫描线一个很经典的例题：在坐标轴上有若干个矩形，问他们覆盖的面积总和。 扫描线求重叠矩形面积 思路 使用一条垂直于X轴的直线，从左到右来扫描这个图形，明显，只有在碰到矩形的左边界或者右边界的时候，这个线段所扫描到的情况才会改变。 所以把所有矩形的入边，出边按 X 值排序。然后根据 X 值从小到大去处理。 用线段树来维护扫描到的情况，即每条线段映射到 Y 轴上进行区间维护。 算法流程
线段树+扫描线问题
Never say never
10-14 846
线段树+扫描线问题。Atlantis线段树+扫描线第一题。之前看过一次，只不过没实现。看了胡浩的线段树专辑再去敲得，其实基本和他写的一样。只是update那里稍有不同，这里划分区间应该是l~mid和mid~r，而不是l~mid和mid+1~r，因为这里指的是连续的区间，而不是离散的点。题目传送：HDU - 1542 - AtlantisAC代码：#include <map> #include <se
线段树辅助——扫描线法计算矩形面积并
菜鸡的博客
05-18 889
线段树辅助——扫描线法计算矩形面积并 本篇文章转自：传送门 分析: 1.矩形比较多，坐标也很大，所以横坐标需要离散化（纵坐标不需要），熟悉离散化后这个步骤不难，所以这里不详细讲解了，不明白的还请百度 2.重点：扫描线法：假想有一条扫描线，从左往右（从右往左），或者从下往上（从上往下）扫描过整个多边形（或者说畸形。。多个矩形叠加后的那个图形）。如果是竖直方向上扫描，则是离散化横坐标，如果是水...
Atlantis poj1151 扫描线+线段树
olahiuj的博客
02-23 445
Description给定一些矩形的左下和右上坐标，求形成图形的总面积Solution嗯这道题按理说离散是可以艹过去的写的优美一些应该没问题毕竟n才100于是我采用了扫描线的做法(滑稽首先把x、y坐标分别离散，然后将横向的线段保存并按x坐标升序排序，这样我们得到的是2n条线段，为了区分我们把矩形的下部线段标为1，上部标为-1接着就建一棵线段树，每次遇到下边就插入一段线段(连续+1)，遇到上边就删除一
杭二学习Day5——专题（线段树&扫描线）
zsyz_ZZY的博客
08-06 211
背景： 补一下昨天的坑。 好像也没有什么补的，水访问量罢了。 线段树： 一种动态区间问题的解决方法。 挂个题表吧：https://blog.csdn.net/zsyz_zzy/article/category/7415002 。 扫描线： 就是假定有一根线，按一个方向扫过，过程中的状态可以用线段树来维护。 挂个题表吧：https://blog.csdn.net/zsyz_zzy/artic...
线段树扫描线的理解
进击的acm小白
07-19 1258
分析: 1.矩形比较多，坐标也很大，所以横坐标需要离散化（纵坐标不需要），熟悉离散化后这个步骤不难，所以这里不详细讲解了，不明白的还请百度 2.重点：扫描线法：假想有一条扫描线，从左往右（从右往左），或者从下往上（从上往下）扫描过整个多边形（或者说畸形。。多个矩形叠加后的那个图形）。如果是竖直方向上扫描，则是离散化横坐标，如果是水平方向上扫描，则是离散化纵坐标。下面的分析都是离散化横坐
POJ - Picture(线段树&扫描线)
ityanger的技术栈
09-05 2510
题目链接:http://poj.org/problem?id=1177 Time Limit: 2000MS Memory Limit: 10000K Description A number of rectangular posters, photographs and other pictures of the same shape are pasted on a wall. Their si...
线段树详解
热门推荐
orz
05-20 1万+
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树之扫描线
05-20
自己参考资料整理出来的ppt，讲解还算比较细致，如有不妥之处请批评指正
权值线段树及扫描线学习笔记
12-25
权值线段树及扫描线学习笔记
算法讲解115【扩展】线段树专题6-线段树与扫描线结合的题目.pptx
最新发布
08-27
代码：https://download.csdn.net/download/m0_73085893/89681787
总结一下最短路径的贝尔曼-福特算法(Bellman-Ford)及用队列优化(spfa)
zxy160的博客
01-17 4745
转发的一二货的：http://blog.csdn.net/riba2534/article/details/54575050 他是从《啊哈算法》上学的，本来想总结一下，一看跟他一模一样，then，，，，，，关于贝尔曼福特算法,假设有n个顶点，我们只需要遍历n-1轮就可以了，因为在一个含n个顶点的图中，任意两点之间的最短路径最多含有n-1条边, 什么原理，我就不讲了，网上大牛博客很多，我在这里上一
BBP算法板子
zxy160的博客
11-07 1964
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=6217 百度BBP解释：https://wenku.baidu.com/view/716dbac708a1284ac85043bf.html 板子，不会，别问我#include <cstdio> #include<iostream> using namespace std; typedef long
LCA，有向图求两点间距离，无向图求两点间距离，倍增
zxy160的博客
01-20 913
LCA就是求公共祖先。优质博客推荐 但是不推荐它的伪代码，感觉思路没错，但是有点问题。 我随手写了一个，有错欢迎之处 int get(int u) { if(f[u]==u) return u; else f[u]=get(f[u]); } void dfs(int u,int pre) { //vis[u]=1;//位置1 for(int i=first...
KMP，找出s字符串在T字符中的位置，或有几个
zxy160的博客
01-25 711
优质博客推荐 hdu1711 #include #include #define mem(a,b) memset(a,b,sizeof(a)) int a[1000005]; int b[10005]; int nex[10005]; int n,m; void KMP() { mem(nex,0); nex[0]=-1; int i=0,k=-1; whi
java大数a+b
zxy160的博客
03-16 698
hdu1000 import java.util.Scanner;//输入 import java.math.BigInteger;//大整数类 import java.math.BigDecimal;//大浮点数类 public class Main { public static void main(String[] args) { Scanner s=new S...
逆序数 poj2299 Ultra-QuickSort
zxy160的博客
03-22 559
Ultra-QuickSort Time Limit: 7000MS Memory Limit: 65536K Total Submissions: 59643 Accepted: 22101 Description In this problem, you have to analyze a particular sorting algorithm. The al
线段树扫描线法提升面积问题求解效率
线段树之扫描线是一种在信息学竞赛中常用的高级数据结构技术，主要用于解决涉及矩形区域的问题，如面积、周长计算，尤其是在矩形可能重叠的情况下。本资料主要介绍如何利用线段树结合扫描线算法来高效处理此类问题。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值