acm专题9——线段树

最新推荐文章于 2022-03-23 15:43:41 发布
最新推荐文章于 2022-03-23 15:43:41 发布
阅读量495 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/HDUCheater/article/details/104559959

代码解析

1.pushdown,pushup模板

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn=100000+10;
ll n,input[maxn];
struct node
{
	ll val,lazy,l,r,len;//lazy用来存储需要向下传的数值信息，等询问时再一起传递
}tree[4*maxn];
void build(ll root,ll l,ll r)
{
	ll m;
	tree[root].lazy=0;
	tree[root].l=l;
	tree[root].r=r;
	tree[root].len=r-l+1;
	if(l==r)
		tree[root].val=input[l];
	else
	{
		m=(l+r)/2;//二分建树
		build(root*2,l,m);//左子树
		build(root*2+1,m+1,r);//右子树
		tree[root].val=tree[root*2].val+tree[root*2+1].val;//pushup
	}
}
void pushdown(ll root)
{
	if(tree[root].lazy)
	{
		tree[root*2].lazy+=tree[root].lazy;//lazy标记传递
		tree[root*2+1].lazy+=tree[root].lazy;//lazy标记传递
		tree[root*2].val+=tree[root*2].len*tree[root].lazy;//lazy值传递该点的值
		tree[root*2+1].val+=tree[root*2+1].len*tree[root].lazy;//lazy值传递该点的值
		tree[root].lazy=0;//lazy标记清零
	}
}
void update(ll root,ll l,ll r,ll x)
{
	if(tree[root].l>=l&&tree[root].r<=r)//更新区间完全覆盖该子树区间
	{
		tree[root].lazy+=x;//更新lazy标记
		tree[root].val+=tree[root].len*x;//更新该点的值
		return;
	}
	if(tree[root].l>r||tree[root].r<l)
		return;
	pushdown(root);//若部分重叠，将lazy值传递下去，直到找到完全覆盖
	update(root*2,l,r,x);//更新左子树
	update(root*2+1,l,r,x);//更新右子树
	tree[root].val=(tree[root*2].val+tree[root*2+1].val);//pushup
}
ll query(ll root,ll l,ll r)
{
	if(tree[root].l>=l&&tree[root].r<=r)
		return tree[root].val;
	if(tree[root].l>r||tree[root].r<l)
		return 0;
	pushdown(root);
	return query(root*2,l,r)+query(root*2+1,l,r);
}
int main()
{
	while(~scanf("%lld",&n))
	{
		build(1,1,n);//建树
	}

    return 0;
}

2.标记永久化模板

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn=50000+10;
ll n,input[maxn];
struct node
{
	ll val,lazy,l,r,len;
}tree[4*maxn];
void build(ll root,ll l,ll r)//build部分不变
{
	ll m;
	tree[root].lazy=0;
	tree[root].l=l;
	tree[root].r=r;
	tree[root].len=r-l+1;
	if(l==r)
		tree[root].val=input[l];
	else
	{
		m=(l+r)/2;
		build(root*2,l,m);
		build(root*2+1,m+1,r);
		tree[root].val=tree[root*2].val+tree[root*2+1].val;
	}
}
void update(ll root,ll l,ll r,ll x)//更新每一个点！
{
	tree[root].val+=(r-l+1)*x;
	if(tree[root].l==l&&tree[root].r==r)//必须完全重合才可加lazy
	{
		tree[root].lazy+=x;
		return;
	}
	ll mid=(tree[root].l+tree[root].r)/2;//下标为root的结点的l与r的中点
	if(r<=mid)//如果更新区间的右边界比这个mid小，那么找这个root的左儿子，缩小区间
		update(root*2,l,r,x);
	else if(l>mid)//如果更新区间的左边界比这个mid大，那么找这个root的右儿子，缩小区间
		update(root*2+1,l,r,x);
	else
	{
		update(root*2,l,mid,x);
		update(root*2+1,mid+1,r,x);
	}
}
ll query(ll root,ll l,ll r,ll ad)//询问时累加标记，标记初始为0
{
	if(tree[root].l==l&&tree[root].r==r)
		return tree[root].val+tree[root].len*ad;
	ll mid=(tree[root].l+tree[root].r)/2;
	if(r<=mid) return query(root*2,l,r,ad+tree[root].lazy);
	if(l>mid) return query(root*2+1,l,r,ad+tree[root].lazy);
	return query(root*2,l,mid,ad+tree[root].lazy)+query(root*2+1,mid+1,r,ad+tree[root].lazy);
}
int main()
{
	while(~scanf("%lld",&n))
	{
		build(1,1,n);
	}
    return 0;
}

主要思想：分治
递归解决问题
优化方案：lazy标记
优化方案2：标记永久化

经典例题

1001-敌兵布阵

题目来源：hdoj(1166)

1.lazytag解法

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long,long long> pll;
const int inf = 0x3f3f3f3f;
const int maxn=100000+10;
ll n,input[maxn];
struct node
{
	ll val,lazy,l,r,len;//lazy用来存储需要向下传的数值信息，等询问时再一起传递
}tree[4*maxn];
void build(ll root,ll l,ll r)
{
	ll m;
	tree[root].lazy=0;
	tree[root].l=l;
	tree[root].r=r;
	tree[root].len=r-l+1;
	if(l==r)
		tree[root].val=input[l];
	else
	{
		m=(l+r)/2;//二分建树
		build(root*2,l,m);//左子树
		build(root*2+1,m+1,r);//右子树
		tree[root].val=tree[root*2].val+tree[root*2+1].val;//pushup
	}
}
void pushdown(ll root)
{
	if(tree[root].lazy)
	{
		tree[root*2].lazy+=tree[root].lazy;//lazy标记传递
		tree[root*2+1].lazy+=tree[root].lazy;//lazy标记传递
		tree[root*2].val+=tree[root*2].len*tree[root].lazy;//lazy值传递该点的值
		tree[root*2+1].val+=tree[root*2+1].len*tree[root].lazy;//lazy值传递该点的值
		tree[root].lazy=0;//lazy标记清零
	}
}
void update(ll root,ll l,ll r,ll x)
{
	if(tree[root].l>=l&&tree[root].r<=r)//更新区间完全覆盖该子树区间
	{
		tree[root].lazy+=x;//更新lazy标记
		tree[root].val+=tree[root].len*x;//更新该点的值
		return;
	}
	if(tree[root].l>r||tree[root].r<l)
		return;
	pushdown(root);//若部分重叠，将lazy值传递下去，直到找到完全覆盖
	update(root*2,l,r,x);//更新左子树
	update(root*2+1,l,r,x);//更新右子树
	tree[root].val=(tree[root*2].val+tree[root*2+1].val);//pushup
}
ll query(ll root,ll l,ll r)
{
	if(tree[root].l>=l&&tree[root].r<=r)
		return tree[root].val;
	if(tree[root].l>r||tree[root].r<l)
		return 0;
	pushdown(root);
	return query(root*2,l,r)+query(root*2+1,l,r);
}
void solve()
{
	scanf("%lld",&n);
	for(ll i=1;i<=n;i++)
		scanf("%lld",&input[i]);
	build(1,1,n);//建树
	string s;
	ll a,b;
	while(cin>>s)
	{
		if(s=="End")
			break;
		cin>>a>>b;
		if(s=="Query")
			printf("%lld\n",query(1,a,b));
		else if(s=="Sub")
			update(1,a,a,-b);
		else if(s=="Add")
			update(1,a,a,b);
	}
    return;
}
int main()
{
	ll T;
	scanf("%lld",&T);
	for(ll t0=1;t0<=T;t0++)
	{
		printf("Case %lld:\n",t0);
		solve();
	}
	return 0;
}

2.标记永久化解法

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn=50000+10;
ll n,input[maxn];
struct node
{
	ll val,lazy,l,r,len;
}tree[4*maxn];
void build(ll root,ll l,ll r)
{
	ll m;
	tree[root].lazy=0;
	tree[root].l=l;
	tree[root].r=r;
	tree[root].len=r-l+1;
	if(l==r)
		tree[root].val=input[l];
	else
	{
		m=(l+r)/2;
		build(root*2,l,m);
		build(root*2+1,m+1,r);
		tree[root].val=tree[root*2].val+tree[root*2+1].val;
	}
}
void update(ll root,ll l,ll r,ll addval)
{
	tree[root].val+=(r-l+1)*addval;
	if(tree[root].l==l&&tree[root].r==r)
	{
		tree[root].lazy+=addval;
		return;
	}
	ll mid=(tree[root].l+tree[root].r)/2;
	if(r<=mid)
		update(root*2,l,r,addval);
	else if(l>mid)
		update(root*2+1,l,r,addval);
	else
	{
		update(root*2,l,mid,addval);
		update(root*2+1,mid+1,r,addval);
	}
}
ll query(ll root,ll l,ll r,ll ad)
{
	if(tree[root].l==l&&tree[root].r==r)
		return tree[root].val+tree[root].len*ad;
	ll mid=(tree[root].l+tree[root].r)/2;
	if(r<=mid) return query(root*2,l,r,ad+tree[root].lazy);
	if(l>mid) return query(root*2+1,l,r,ad+tree[root].lazy);
	return query(root*2,l,mid,ad+tree[root].lazy)+query(root*2+1,mid+1,r,ad+tree[root].lazy);
}
void solve()
{
	scanf("%lld",&n);
	for(ll i=1;i<=n;i++)
		scanf("%lld",&input[i]);
	build(1,1,n);//建树
	string s;
	ll a,b;
	while(cin>>s)
	{
		if(s=="End")
			break;
		cin>>a>>b;
		if(s=="Query")
			printf("%lld\n",query(1,a,b,0));
		else if(s=="Sub")
			update(1,a,a,-b);
		else if(s=="Add")
			update(1,a,a,b);
	}
    return;
}
int main()
{
	ll T;
	scanf("%lld",&T);
	for(ll t0=1;t0<=T;t0++)
	{
		printf("Case %lld:\n",t0);
		solve();
	}
	return 0;
}

易错点：全部用cin读入会超时！！！还是尽量多用scanf为好

1002-I Hate It

题目来源：hdoj1754

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn=200000+10;
ll n,m,input[maxn];
struct node
{
	ll val,l,r;
}tree[4*maxn];
void build(ll root,ll l,ll r)//build部分不变
{
	ll m;
	tree[root].l=l;
	tree[root].r=r;
	if(l==r)
		tree[root].val=input[l];
	else
	{
		m=(l+r)/2;
		build(root*2,l,m);
		build(root*2+1,m+1,r);
		tree[root].val=max(tree[root*2].val,tree[root*2+1].val);
	}
}
void update(ll root,ll l,ll r,ll x)
{
	if(tree[root].l>=l&&tree[root].r<=r)
	{
		tree[root].val=x;
		return;
	}
	if(tree[root].l>r||tree[root].r<l)
		return;
	update(root*2,l,r,x);
	update(root*2+1,l,r,x);
	tree[root].val=max(tree[root*2].val,tree[root*2+1].val);
}
ll query(ll root,ll l,ll r)
{
	if(tree[root].l>=l&&tree[root].r<=r)
		return tree[root].val;
	if(tree[root].l>r||tree[root].r<l)
		return 0;
	return max(query(root*2,l,r),query(root*2+1,l,r));
}
void solve()
{
	build(1,1,n);
	while(m--)
	{
		char c;
		ll a,b;
		cin>>c>>a>>b;
		if(c=='Q')
			printf("%lld\n",query(1,a,b));
		else
			update(1,a,a,b);
	}
    return;
}
int main()
{
	while(~scanf("%lld%lld",&n,&m))
	{
		for(ll i=1;i<=n;i++)
			scanf("%lld",&input[i]);
		solve();
	}
	return 0;
}

1003-A Simple Problem with Integers

题目来源：hdoj4267

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn=50000+1;
int n,input[maxn];
struct node
{
	int val,l,r;
	int sum[57];
}tree[4*maxn];
void build(int root,int l,int r)//build部分不变
{
	int m;
	memset(tree[root].sum,0,sizeof(tree[root].sum));
	tree[root].l=l;
	tree[root].r=r;
	if(l==r)
		tree[root].val=input[l];
	else
	{
		m=(l+r)/2;
		build(root*2,l,m);
		build(root*2+1,m+1,r);
	}
}
void update(int root,int l,int r,int k,int x)
{
	if(tree[root].l>=l&&tree[root].r<=r)
	{
		tree[root].sum[k*(k-1)/2+(tree[root].l-l)%k]+=x;
		return;
	}
	if(tree[root].l>r||tree[root].r<l)
		return;
	update(root*2,l,r,k,x);
	update(root*2+1,l,r,k,x);
}
int query(int root,int x)
{
	if(tree[root].l>x||tree[root].r<x)
		return 0;
	int ans=0;
	for(int i=1;i<=10;i++)
        for(int j=0;j<i;j++)
            if((x-tree[root].l+j)%i==0)
				ans+=tree[root].sum[i*(i-1)/2+j];
	if(tree[root].l==tree[root].r)
		return ans+=tree[root].val;
	int m=(tree[root].l+tree[root].r)/2;
	return ans+=query(root*2,x)+query(root*2+1,x);
}
void solve()
{
	build(1,1,n);
	int m,op,a,b,c,d;
	scanf("%d",&m);
	while(m--)
	{
		scanf("%d",&op);
		if(op==1)
		{
			scanf("%d%d%d%d",&a,&b,&c,&d);
			update(1,a,b,c,d);
		}
		else
		{
			scanf("%d",&a);
			printf("%d\n",query(1,a));
		}
	}
    return;
}
int main()
{
	while(~scanf("%d",&n))
	{
		for(int i=1;i<=n;i++)
			scanf("%d",&input[i]);
		solve();
	}
	return 0;
}

这题让我推开了新世界的大门
首先先说一下坑点，如果你是一位longlongint选手，那么恭喜你，你很有可能会像我一样，memory limited exceeded。请不要没事define int long long int
对这个sum做一点解释：
k*(k-1)/2就是0到k-1的和
比方说k=1的时候，这个和就是0，余数必然为0，存储一种情况（sum[0])
k=2的时候，这个和就是1，此时余数可以为0或为1，存储两种情况(sum[1+0],sum[1+1])
k=3的时候，这个和就是3，此时余数可以为0或为1或为2，存储两种情况(sum[3+0],sum[3+1]，sum[3+2])

1004-Just a Hook

题目来源：hdoj1698

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long,long long> pll;
const int inf = 0x3f3f3f3f;
const int maxn=100000+10;
ll n,input[maxn];
struct node
{
	ll val,lazy,l,r,len;
}tree[4*maxn];
void build(ll root,ll l,ll r)
{
	ll m;
	tree[root].lazy=0;
	tree[root].l=l;
	tree[root].r=r;
	tree[root].len=r-l+1;
	if(l==r)
		tree[root].val=1;
	else
	{
		m=(l+r)/2;
		build(root*2,l,m);
		build(root*2+1,m+1,r);
		tree[root].val=tree[root*2].val+tree[root*2+1].val;
	}
}
void pushdown(ll root)
{
	if(tree[root].lazy)
	{
		tree[root*2].lazy=tree[root].lazy;
		tree[root*2+1].lazy=tree[root].lazy;
		tree[root*2].val=tree[root*2].len*tree[root].lazy;
		tree[root*2+1].val=tree[root*2+1].len*tree[root].lazy;
		tree[root].lazy=0;
	}
}
void update(ll root,ll l,ll r,ll x)
{
	if(tree[root].l>=l&&tree[root].r<=r)
	{
		tree[root].lazy=x;
		tree[root].val=tree[root].len*x;
		return;
	}
	if(tree[root].l>r||tree[root].r<l)
		return;
	pushdown(root);
	update(root*2,l,r,x);
	update(root*2+1,l,r,x);
	tree[root].val=(tree[root*2].val+tree[root*2+1].val);
}
ll query(ll root,ll l,ll r)
{
	if(tree[root].l>=l&&tree[root].r<=r)
		return tree[root].val;
	if(tree[root].l>r||tree[root].r<l)
		return 0;
	pushdown(root);
	return query(root*2,l,r)+query(root*2+1,l,r);
}
void solve()
{
	ll m;
	ll a,b,c;
	scanf("%lld%lld",&n,&m);
	build(1,1,n);
	while(m--)
	{
		scanf("%lld%lld%lld",&a,&b,&c);
		update(1,a,b,c);
	}
	printf("%lld.\n",query(1,1,n));
    return;
}
int main()
{
	ll T;
	scanf("%lld",&T);
	for(ll i=1;i<=T;i++)
	{
		printf("Case %lld: The total value of the hook is ",i);
		solve();
	}
	return 0;
}

模板题

1005-LCIS

题目来源：hdoj3308

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int inf=0x3f3f3f3f;
const int maxn=1e5+10000;
int n,m,a,b,t,ans;
int x[maxn];
char op[2];

struct node{
    int l,r; //左右边界
    int ls,rs; //左右边界的值
    int lsum,rsum,sum; //左右最大LCIS 区间最大LCIS
}tree[maxn*4];

void pushup(int rt)
{
    tree[rt].ls=tree[rt*2].ls;
    tree[rt].rs=tree[rt*2+1].rs;
    tree[rt].lsum=tree[rt*2].lsum;
    tree[rt].rsum=tree[rt*2+1].rsum;
    tree[rt].sum=max(tree[rt*2].sum,tree[rt*2+1].sum);
    if(tree[rt*2].rs<tree[rt*2+1].ls)
	{//如果左子树的右边界值小于右子树的左边界值 合并左子树的右边界和右子树的左边界进行计算
        if(tree[rt*2].lsum==(tree[rt*2].r-tree[rt*2].l+1))
            tree[rt].lsum+=tree[rt*2+1].lsum;
        if(tree[rt*2+1].rsum==(tree[rt*2+1].r-tree[rt*2+1].l+1))
            tree[rt].rsum+=tree[rt*2].rsum;
        tree[rt].sum=max(tree[rt].sum,tree[rt*2].rsum+tree[rt*2+1].lsum);
    }
}

void build(int l,int r,int rt)
{
    tree[rt].l=l;
    tree[rt].r=r;
    if(l==r)
	{
        tree[rt].lsum=tree[rt].rsum=tree[rt].sum=1;
        tree[rt].ls=tree[rt].rs=x[l];
        return;
    }
    int mid=(l+r)/2;
    build(l,mid,rt*2);
    build(mid+1,r,rt*2+1);
    pushup(rt);
}

void update(int rt)
{
    if(tree[rt].l==tree[rt].r)
	{
        tree[rt].ls=tree[rt].rs=b;
        return;
    }
    int mid=(tree[rt].l+tree[rt].r)/2;
    if(a<=mid) update(rt*2);
    else update(rt*2+1);
    pushup(rt);
}

int query(int rt)
{
    if(tree[rt].l>=a && tree[rt].r<=b)
        return tree[rt].sum;
    int mid=(tree[rt].l+tree[rt].r)/2;
    int ans=0;
    if(a<=mid) ans=max(ans,query(rt*2));
    if(b>mid) ans=max(ans,query(rt*2+1));
    if(tree[rt*2].rs<tree[rt*2+1].ls)
        ans=max(ans,min(mid-a+1,tree[rt*2].rsum)+min(b-mid,tree[rt*2+1].lsum));
    return ans;
}

int main()
{
    scanf("%d",&t);
    while(t--)
	{
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            scanf("%d",&x[i]);
        build(1,n,1);
        for(int i=1;i<=m;i++)
		{
            scanf("%s%d%d",op,&a,&b);
            if(op[0]=='U')
			{
                a++;
                update(1);
            }
            if(op[0]=='Q')
			{
                a++;b++;
                printf("%d\n",query(1));
            }
        }
    }
    return 0;
}
九幽孤翎
关注
[ACM] 线段树经典题
红黑树的落叶
04-15 1010
POJ 2528 Mayor’s posters m次区间染色，每次染色使用的颜色都不同，颜色可以覆盖，最后询问颜色数量，区间大小n为1e7，m为1e4。 做法一： 使用线段树，区间染色时间复杂度O(logn)，由于只询问一次颜色，可以O(n)遍历线段树暴力查询颜色数量。由于这道题有多组数据，O(n)的复杂度可能过不去，因此需要事先离散化一下，复杂度降为O(mlogm)，此题离散化有陷阱，具体参见...
线段树专题
far away
08-16 838
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1166 敌兵布阵 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 97473    Accepted Submi
ACM 线段树
oyasherkin的博客
07-12 398
求给定区间中的最值问题。对于长度为n的数列A，求数组A中下标在[i，j]里的最小值。 注： 这里下标从1开始 输入： 第一行两个整数n和q，分别表示数列的长度和询问的次数。 接下来n行为n个整数，表示数列A中的元素。 接下来q行中，每行有两个整数，表示所询问的区间[I, j]的两个端点 输出： 对每一个询问，给出指定区间中的最小值 样例输入： 9 2 5 8 1 3 6 4 9
ACM_线段树
CODER的博客
07-03 307
开始线段树的学习 几个概念 RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j&amp;amp;amp;amp;lt;=n)，返回数列A中下标在i,j里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题。 一.基础知识 1、线段树是一棵二叉搜索树，它储存的是一个区间的信息。 2、每个节点以结构体的方式存储，结构体包含以下几个信...
acm算法之线段树
向大神努力的菜鸟
05-17 1356
线段树 (1)基础线段树 例题：（单点修改 区间求解） Description C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增
ACM入门之【线段树】
辉小歌的博客
03-23 1640
线段树是算法竞赛中常用的用来维护 区间信息 的数据结构。 线段树可以在 O(logN)的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间最大值，求区间最小值）等操作。 线段树相对于树状数组代码较长，但是线段树较全面，功能性更强。 线段树的基本分为两类： 单点修改，不需要懒标记。 pushup: 由子节点向上更新父节点 bulild: 一段区间初始化成线段树 modify:修改 query:查询 区间修改，需要懒标记。 pushup: 由子节点向上更新父节点 pushdown: 由父
计算几何专题题库及详解——ACM算法学习资源
- 可能涉及较为复杂的线段处理技术，如线段树、区间树等高级数据结构。 - 线段处理在图形学中非常关键，如扫描线算法解决可见性问题。 - 可能也涉及到如何高效地处理大量线段的并集、交集等问题。 4. **1204...
【算法竞赛学习笔记】平衡树专题——替罪羊树
SC_Linno的博客
02-08 1111
title : 平衡树专题之替罪羊树 date : 2022-2-8 tags : ACM,数据结构，平衡树 author : Linno 替罪羊树 替罪羊树是一种非常优(bao)雅(li)的平衡树，与普通平衡树的区别是，它维护平衡的方式不是旋转，而是重构。尽管重构的过程是非常暴力的，复杂度依然是很好的O(logn)O(logn)O(logn) 准备工作 需要储存的信息：左右子树编号、当前结点的值、以当前结点为根的树的大小和实际大小、删除标记。 struct Node int l,r,val; /.
ACM入门教材
09-07
③计算几何：计算几何相比于其它部分来说是比较独立的，就是说它和其它的知识点很少有过多的结合，较常用到的部分包括——线段相交的判断、多边形面积的计算、内点外点的判断、凸包等等。④线性代数：对线性代数的...
ACM常用函数
05-31
9. 点到线段最短距离：实现了点到线段最短距离的计算，使用了矢量运算。 10. 求两直线的交点：实现了两直线交点的计算，使用了矢量运算。 11. 判断一个封闭图形是凹集还是凸集：实现了封闭图形是凹集还是凸集的判断...
ACM知识----线段树
qq_43632924的博客
10-31 248
近几天有些自闭，我觉得自己身上有太多的东西没有学会，我决定一点点来，每天争取学一个知识点，今天份记录，线段树。 线段树是一种以二叉树为原型，将树形结构各个节点划分为区间的一种结构，其中全部的区间就是根节点，如一个节点【l，r】，其子节点就是【l，l+r/2】与【（l+r）/2+1，r】，也就是把区间二等分，直到最后的叶子节点全部都是一个单一数据。 如果区间长度为n，那么树的高度最大为log2（...
线段树入门（ACM）
LHBLL的博客
08-26 257
功能： 延迟区间加乘，加速区间查询。 个人看法： 将区间不断二分，直到成点。 同时可以用结构体辅助记录每一段的信息：左右结点，区间和，懒惰标记。（递归思想） 结构： 1.根据初始数据建立线段树：函数build 2.加法（减法）：函数add 3.乘法：函数mul 4.查询区间之和：函数search 例题1：加法+懒惰标记 题目背景 P3372 【模板】线段树 1 同时适用于 P3374 【模板】树状数组 1 P3368 【模板】树状数组 2 //build(1,1,...
【完全版】线段树（转载）
weixin_30836759的博客
08-11 365
转载自：http://www.notonlysuccess.com/ 膜拜之。。。 【完全版】线段树 很早前写的那篇线段树专辑至今一直是本博客阅读点击量最大的一片文章,当时觉得挺自豪的,还去pku打广告,但是现在我自己都不太好意思去看那篇文章了,觉得当时的代码风格实在是太丑了,很多线段树的初学者可能就是看着这篇文章来练习的,如果不小心被我培养出了这么糟糕的风格,实在是过意不去,正好过几天又要...
ACM——线段树
weixin_40446193的博客
05-09 271
线段树模板: /*定义*/ const int MAXN=50010; int a[MAXN],ans[MAXN<<2],lazy[MAXN<<2]; //a[]为原序列信息，ans[]模拟线段树维护区间和，lazy[]为懒惰标记 /*更新结点信息*/ void PushUp(int rt) { ans[rt]=ans[rt<<1]+ans[rt&lt...
ACM-线段树
weixin_30819163的博客
07-21 88
http://blog.youkuaiyun.com/libin56842/article/details/8530197 基础可以看上面这篇文章 风格： maxn是题目给的最大区间，而节点数要开4倍，确切的说…… lson和rson辨别表示结点的左孩子和右孩子。 PushUp(int rt)是把当前结点的信息更新到父节点 PushDown（int rt)是把当前结点的信息更新给孩子结...
ACM---线段树个人理解
Forgetxbw的博客
05-27 393
          线段树 定义：   线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[...
acm线段树
小田坎儿
07-14 917
Description In the game of DotA, Pudge’s meat hook is actually the most horrible thing for most of the heroes. The hook is made up of several consecutive metallic sticks which are of the same lengt
ACM_大牛总结的线段树专辑
知足常乐的博客
08-15 1166
【完全版】线段树 很早前写的那篇线段树专辑至今一直是本博客阅读点击量最大的一片文章,当时觉得挺自豪的,还去pku打广告,但是现在我自己都不太好意思去看那篇文章了,觉得当时的代码风格实在是太丑了,很多线段树的初学者可能就是看着这篇文章来练习的,如果不小心被我培养出了这么糟糕的风格,实在是过意不去,正好过几天又要给集训队讲解线段树,所以决定把这些题目重新写一遍,顺便把近年我接触到的一些新题更新上去~;并
ACM常用模板——数据结构——线段树
kukajenny的博客
11-17 1068
ACM常用模板——数据结构——线段树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值