线！线！线！线段树

最新推荐文章于 2022-05-18 06:00:00 发布
最新推荐文章于 2022-05-18 06:00:00 发布
阅读量344 收藏
点赞数 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 2351
扫描线（难的批爆）
线段树之扫描线（HDU-1542）
月巴虫丰博客
05-13 493
线段树之扫描线，主要是为了解决平面矩阵并以及空间立体交的问题。
扫描线（线段树）
Cauchy的博客
05-18 1935
文章目录扫描线扫描线求重叠矩形面积思路算法流程性质经典例题247. 亚特兰蒂斯 扫描线 线段树的一大应用是扫描线。 扫描线一个很经典的例题：在坐标轴上有若干个矩形，问他们覆盖的面积总和。 扫描线求重叠矩形面积 思路 使用一条垂直于X轴的直线，从左到右来扫描这个图形，明显，只有在碰到矩形的左边界或者右边界的时候，这个线段所扫描到的情况才会改变。 所以把所有矩形的入边，出边按 X 值排序。然后根据 X 值从小到大去处理。 用线段树来维护扫描到的情况，即每条线段映射到 Y 轴上进行区间维护。 算法流程
线段树+扫描线问题
Never say never
10-14 860
线段树+扫描线问题。Atlantis线段树+扫描线第一题。之前看过一次，只不过没实现。看了胡浩的线段树专辑再去敲得，其实基本和他写的一样。只是update那里稍有不同，这里划分区间应该是l~mid和mid~r，而不是l~mid和mid+1~r，因为这里指的是连续的区间，而不是离散的点。题目传送：HDU - 1542 - AtlantisAC代码：#include <map> #include <se
线段树辅助——扫描线法计算矩形面积并
菜鸡的博客
05-18 917
线段树辅助——扫描线法计算矩形面积并 本篇文章转自：传送门 分析: 1.矩形比较多，坐标也很大，所以横坐标需要离散化（纵坐标不需要），熟悉离散化后这个步骤不难，所以这里不详细讲解了，不明白的还请百度 2.重点：扫描线法：假想有一条扫描线，从左往右（从右往左），或者从下往上（从上往下）扫描过整个多边形（或者说畸形。。多个矩形叠加后的那个图形）。如果是竖直方向上扫描，则是离散化横坐标，如果是水...
Atlantis poj1151 扫描线+线段树
olahiuj的博客
02-23 455
Description给定一些矩形的左下和右上坐标，求形成图形的总面积Solution嗯这道题按理说离散是可以艹过去的写的优美一些应该没问题毕竟n才100于是我采用了扫描线的做法(滑稽首先把x、y坐标分别离散，然后将横向的线段保存并按x坐标升序排序，这样我们得到的是2n条线段，为了区分我们把矩形的下部线段标为1，上部标为-1接着就建一棵线段树，每次遇到下边就插入一段线段(连续+1)，遇到上边就删除一
杭二学习Day5——专题（线段树&扫描线）
zsyz_ZZY的博客
08-06 222
背景： 补一下昨天的坑。 好像也没有什么补的，水访问量罢了。 线段树： 一种动态区间问题的解决方法。 挂个题表吧：https://blog.csdn.net/zsyz_zzy/article/category/7415002 。 扫描线： 就是假定有一根线，按一个方向扫过，过程中的状态可以用线段树来维护。 挂个题表吧：https://blog.csdn.net/zsyz_zzy/artic...
线段树扫描线的理解
进击的acm小白
07-19 1268
分析: 1.矩形比较多，坐标也很大，所以横坐标需要离散化（纵坐标不需要），熟悉离散化后这个步骤不难，所以这里不详细讲解了，不明白的还请百度 2.重点：扫描线法：假想有一条扫描线，从左往右（从右往左），或者从下往上（从上往下）扫描过整个多边形（或者说畸形。。多个矩形叠加后的那个图形）。如果是竖直方向上扫描，则是离散化横坐标，如果是水平方向上扫描，则是离散化纵坐标。下面的分析都是离散化横坐
POJ - Picture(线段树&扫描线)
ityanger的技术栈
09-05 2516
题目链接: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...
亚特兰蒂斯【线段树+扫描线+离散化】
Alan_Lowe
03-08 1030
亚特兰蒂斯【线段树+扫描线+离散化】 POJ1151、ACwing247 题目： 有几个古希腊书籍中包含了对传说中的亚特兰蒂斯岛的描述。 其中一些甚至包括岛屿部分地图。 但不幸的是，这些地图描述了亚特兰蒂斯的不同区域。 您的朋友 Bill 必须知道地图的总面积。 你自告奋勇写了一个计算这个总面积的程序。 输入格式： 输入包含多组测试用例。 对于每组测试用例，第一行包含整数 nn，表示总的地图数量。 接下来 n 行，描绘了每张地图，每行包含四个数字 x1,y1,x2,y2（不一定是整数），(x1,y1) 和
线段树之扫描线
05-20
自己参考资料整理出来的ppt，讲解还算比较细致，如有不妥之处请批评指正
权值线段树及扫描线学习笔记
12-25
权值线段树及扫描线学习笔记
算法讲解115【扩展】线段树专题6-线段树与扫描线结合的题目.pptx
最新发布
08-27
代码：https://download.csdn.net/download/m0_73085893/89681787
总结一下最短路径的贝尔曼-福特算法(Bellman-Ford)及用队列优化(spfa)
zxy160的博客
01-17 4757
转发的一二货的：http://blog.csdn.net/riba2534/article/details/54575050 他是从《啊哈算法》上学的，本来想总结一下，一看跟他一模一样，then，，，，，，关于贝尔曼福特算法,假设有n个顶点，我们只需要遍历n-1轮就可以了，因为在一个含n个顶点的图中，任意两点之间的最短路径最多含有n-1条边, 什么原理，我就不讲了，网上大牛博客很多，我在这里上一
BBP算法板子
zxy160的博客
11-07 1981
题目链接: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 927
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 724
优质博客推荐 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 712
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 572
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、付费专栏及课程。

余额充值