struct TREE{
//线段树
}tree[N<<2];
// << 左移运算符，相当于*2^n操作
// >> 右移运算符，相当于/2^n操作
// | 或运算符
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define ls rt<<1
#define rs rt<<1|1
void pushup(){
//节点上传
}
void pushdown(){
//标记下传
}
void build(){
//建树
}
void update(){
//区间更新
}
void query(){
//区间询问
}
区间统计
给你一段区间，区间中的每个点都维护着一个值，问[L,R]区间中所有点的值的总和。
线段树的基础用法，维护不同区间中的和，思路也比较简单。
例题：找不到只考区间统计的题，下面会有题用到。
区间最值
一段区间内每个点都维护着一个值，问[L,R]区间中的最值是多少
线段树基础用法+1，不过是区间统计维护每个点的总和改为最值，思路简单+1
例题：HDU 1754： I Hate It（区间修改+区间最值）
题意：两种操作，第一种操作询问[A,B]区间的最高成绩，第二种是将A同学的成绩改成B。单点修改+区间最值板子题（单点修改在下面会介绍）。不过这题我利用树状数组去做了，目前没有线段树的实现（树状数组敲这题有点烦）
单点修改
一段区间内每个点都维护着一个值，但是会对单个点进行修改，然后在修改的过程中问你以上两种询问。
线段树基础用法+2，基础思路是update到最后一个点（目标点），然后在回溯的过程中不断pushup更新父节点。
例题：HDU 1166：敌兵布阵（单点修改+区间统计）
题意：初始给你敌军营地每个军营的敌人数量，有三种操作，第一二种表示第i个军营增加或者减少j个敌人，然后第三种操作是询问区间[i,j]敌人的数量。线段树单点修改区间访问板子题。
#include<iostream>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<string>
#include<string.h>
#include<queue>
#include<functional>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "<<a<<endl
#define dd(a) cout<<#a<<" = "<<a<<" "
#define be begin
#define en end
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int tree[200005];
void pushup(int rt){
tree[rt] = tree[rt<<1]+tree[rt<<1|1];//统计左右儿子的和
}
int build(int l, int r, int rt){//建树
if(l == r){
cin >> tree[rt];
return tree[rt];
}
int mid = (l + r) >> 1;
return tree[rt] = build(l, mid, rt<<1) + build(mid+1, r, rt<<1|1);
}
void update(int p, int t, int l, int r, int rt){//更新
if(l == r){
tree[rt] += t;
return;
}
int mid = (l + r) >> 1;
if(p <= mid) update(p, t, l, mid, rt<<1);
else update(p, t, mid+1, r, rt<<1|1);
pushup(rt);
}
int query(int L, int R, int l, int r, int rt){//询问
if(L<=l && r<=R) return tree[rt];
int mid = (l + r)>>1;
int sum = 0;
if(L <= mid) sum += query(L,R,l,mid,rt<<1);
if(mid+1 <= R) sum += query(L,R,mid+1,r,rt<<1|1);
return sum;
}
int main()
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
int T;
cin >> T;
int t = 0;
while(T--){
cin >> n;
cout << "Case " << ++t << ':' << endl;
build(1,n,1);
string s;
while(cin >> s){
if(s == "End") break;
int i,j;
cin >> i >> j;
if(s == "Query") cout << query(i,j,1,n,1) << endl;
if(s == "Add") update(i, j, 1, n, 1);
if(s == "Sub") update(i, -j, 1, n, 1);
}
}
return 0;
}
区间修改
一段区间内每个点都维护着一个值，但是会对一段区间的每个点进行修改，然后在修改的过程中问你以上两种询问。
线段树基础用法，基础思路是update到区间内的最后一个点（目标点），然后在回溯的过程中不断pushup更新父节点，但是对于一些数据量不是很大的题目中这么做及时单步操作不止 O(logn)也会超时，多数情况下就要用到后面会将的lazy-tag(懒惰标记)了。
例题：POJ 3468：A Simple Problem with Integers（区间修改+区间统计+懒惰标记）
题意：给定初始值，两种操作，一种是在区间[a,b]上增加c，另一种是询问区间[a,b]的和。区间修改+区间统计板子题。不过这题由于数字区间太大，直接开这么大的线段树妥妥炸，需要离散化
#include<iostream>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<string>
#include<string.h>
#include<queue>
#include<functional>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "<<a<<endl
#define dd(a) cout<<#a<<" = "<<a<<" "
#define be begin
#define en end
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
struct TREE{
ll sum, lay;
}tree[(100005)<<2];
void pushup(int rt){//统计左右儿子的和
tree[rt].sum = tree[rt<<1].sum + tree[rt<<1|1].sum;
}
void pushdown(int rt, int i){//下传标记
if(tree[rt].lay){
ll lay = tree[rt].lay;
tree[rt].lay = 0;//注意清除标记
tree[rt<<1].lay += lay;
tree[rt<<1|1].lay += lay;
tree[rt<<1].sum += lay*(i-(i>>1));
tree[rt<<1|1].sum += (i>>1)*lay;
}
}
void build(int l,int r,int rt){//建树
if(l == r){
scanf("%lld", &tree[rt].sum);
return;
}
int mid = (l+r)/2;
build(l, mid, rt<<1);
build(mid+1, r, rt<<1|1);
pushup(rt);
return;
}
void update(int t, int L, int R,int l, int r, int rt){//更新
if(L <= l && r <= R){//到这里更新就可以结束了
tree[rt].lay += t;//打个标记，剩下的让标记完成
tree[rt].sum += t*(r-l+1);
return;
}
pushdown(rt, r-l+1);
int mid = (l+r)/2;
if(L <= mid) update(t,L,R,l,mid,rt<<1);
if(R > mid) update(t,L,R,mid+1,r,rt<<1|1);
pushup(rt);
}
ll query(int L,int R,int l,int r,int rt){//查询
if(L <= l && r <= R){
return tree[rt].sum;
}
pushdown(rt, r-l+1);//记得下放标记
ll sum = 0;
int mid = (l+r)/2;
if(L <= mid) sum += query(L,R,l,mid,rt<<1);
if(mid < R) sum += query(L,R,mid+1,r,rt<<1|1);
return sum;
}
int main()
{
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
int n,m;
cin >> n >> m;
build(1,n,1);
while(m--){
char q;
int a,b;
cin >> q;
scanf("%d%d", &a, &b);
if(q == 'C'){
int c;
scanf("%d", &c);
update(c,a,b,1,n,1);
}
if(q == 'Q')
cout << query(a,b,1,n,1) << endl;
}
return 0;
}
以上都是线段树的基础操作，接下来总结一下基础的骚操作
lazy-tag(懒惰标记)
对于一段区间的更新，多数情况下可能是不需要更新的那么详细的，因为询问操作很有可能到这一步就截然而止了，儿子的大小并不会被询问函数关注到，因此儿子的更新在这种情况下就并不显得那么重要，所以更新时完全没必要更新到儿子。
打个比方，比如我现在在[1,10]这段区间中需要更新，但是我在下一次询问的时候询问[1,5]，很显然[1,3]和[4,5]以及它们的子区间并不会被询问到，因此我只需要更新到[1,5]区间就可以了。但是，加入你下下次的询问区间[1,3]，这个时候如果不更新节点，那么这次的更新就会失效！因为你的更新在[1,5]就停止了！那么怎么办呢？我可不可以做一个标记，在我询问[1,3]区间的时候就可以利用这个标记继续更新[1,3]了！这个标记就叫lazy-tag，中文名懒惰标记。
但是懒惰标记对于初学者来说是学习线段树的第一道坎，对于每一种操作的标记不仅有不同的叠加方式，对于多种标记共同存在的情况顺序还不好处理，确实是要花一定时间思考的。
例题：HDU 4578：Transformation（区间修改+区间统计+懒惰标记）
题意：四种操作，第一种是将[x,y]区间替换成c，第二种是将[x,y]区间全部加c，第三种是将[x,y]区间全部乘c，第四种是询问[x,y]区间所有的值的p方和(1≤p≤3)。
题解：懒惰标记教你做人题，标记关系和维护方案都很难理解，码量也在惊人的200行，DeBug都能累死。
好在只要求1-3次方的和，那么我们就维护三棵线段树：区间一次方的和、二次方的和、三次方的和，更新时三棵树同时更新。
讲一下多种标记如何解决。第一种标记set标记比较简单粗暴，直接把add标记和mul标记清空(注意，加懒惰标记清为0，乘懒惰标记清为1)，优先级最高。
接着是mul和add标记，比较难处理他们的关系，我们用一个例子解释
假设原来的值为x，它首先经历了乘法标记a，变成a*x。接下来加进来一个值b，变成了(ax+b)，然后现在关键来了，我们乘进来一个值c，那么原本的乘法标记(mullazy == a)和加法标记(addlazy == b)要怎么处理呢？先观察它乘进来是啥：(ax+b)*c，根据分配率，它会变成a*cx+b*c，那么乘法标记不就是(mullazy == a*c)，加法标记就是(addlazy == b*c)，而这时再加一个d，(mullazy*x+addlazy)+d，也就addlazy+=d了，也就是说：当一个乘法标记a进来时，mullazy *= a，addlazy *= a；而一个加法标记b进来时，只要addlazy += b即可，而且从例子中也可以看出，对于值x，在处理时先乘上mullazy，在加上addlazy，即 X = (mullazy*x + addlazy)。
接下来就是p次方的和了，这需要用到这个：
(a+b)^2 = a2+2ab+b2
(a+b)^3 = a^3 + 3a^2b + 3ab^2 + c^3
我们虽然可以很快的得到答案，但是在加法懒惰标记的更新上，我们需要用到上面的公式。即
(sum1+a) = sum1+a
(sum2+a)^2 = sum2 + 2sum2*a + a^2
(sum3+a)^3 = sum3 + 3sum3^2*a + 3sum3*a^2 + a^3
具体操作还是看代码吧
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<string>
#include<string.h>
#include<queue>
#include<functional>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "<<a<<endl
#define dd(a) cout<<#a<<" = "<<a<<" "
#define be begin
#define en end
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int mod = 10007;
struct TREE {
ll sum1, sum2, sum3, add, mul, sets;
//sum1:一次方的和
//sum2:二次方的和
//sum3:三次方的和
//剩下的是标记
}tree[100005 << 2];
inline void Set(ll sets,int rt,ll i) {//重置标记操作
tree[rt].sum1 = (sets*i) % mod;
tree[rt].sum2 = (sets*sets*i) % mod;
tree[rt].sum3 = (sets*sets*sets*i) % mod;
}
inline void Add(ll add,int rt,ll i) {//加标记操作
tree[rt].add = (tree[rt].add + add) % mod;
tree[rt].sum3 = (tree[rt].sum3 + (add*add*add*i % mod) + 3 * add*((tree[rt].sum2 + tree[rt].sum1*add) % mod) % mod) % mod;
tree[rt].sum2 = (tree[rt].sum2 + (add*add*i % mod + (2 * add*tree[rt].sum1) % mod) % mod) % mod;
tree[rt].sum1 = (tree[rt].sum1 + add * i % mod) % mod;
}
inline void Mul(ll mul, int rt) {//乘标记操作
tree[rt].mul = (tree[rt].mul*mul) % mod;
tree[rt].add = (tree[rt].add*mul) % mod;
tree[rt].sum1 = (tree[rt].sum1*mul) % mod;
tree[rt].sum2 = (tree[rt].sum2*mul*mul) % mod;
tree[rt].sum3 = (tree[rt].sum3*mul*mul*mul) % mod;
}
//以上操作在上面又讲
inline void pushup(int rt) {//上传左右儿子的和
tree[rt].sum1 = (tree[rt << 1].sum1 + tree[rt << 1 | 1].sum1) % mod;
tree[rt].sum2 = (tree[rt << 1].sum2 + tree[rt << 1 | 1].sum2) % mod;
tree[rt].sum3 = (tree[rt << 1].sum3 + tree[rt << 1 | 1].sum3) % mod;
}
inline void pushdown(int rt, int i) {//下传标记，注意优先级
if (tree[rt].sets != 0) {
ll sets = tree[rt].sets;
tree[rt].sets = 0;
tree[rt << 1].sets = tree[rt << 1 | 1].sets = sets;
Set(sets, rt << 1, i - (i >> 1));
Set(sets, rt << 1 | 1, (i >> 1));
tree[rt << 1].add = tree[rt << 1 | 1].add = 0;
tree[rt << 1].mul = tree[rt << 1 | 1].mul = 1;
}
if (tree[rt].mul != 1) {
ll mul = tree[rt].mul;
tree[rt].mul = 1;
Mul(mul, rt << 1);
Mul(mul, rt << 1 | 1);
}
if (tree[rt].add != 0) {
ll add = tree[rt].add;
tree[rt].add = 0;
Add(add, rt << 1, i - (i >> 1));
Add(add, rt << 1 | 1, i >> 1);
}
}
inline void update(ll t, ll q, ll L, ll R, int l, int r, int rt) {//更新
if (tree[rt].mul == 0) tree[rt].mul = 1;//这个是初始化乘法标记用的，循环初始化居然会T，8秒诶，用个memset快了6秒多！
if (L <= l && r <= R) {//更新到这里就可以停了，记得打标记
if (q == 1) {
Add(t, rt, r - l + 1);
}
if (q == 2) {
Mul(t, rt);
}
if (q == 3) {
tree[rt].mul = 1;
tree[rt].add = 0;
tree[rt].sets = t;
Set(t, rt, r - l + 1);
}
return;
}
pushdown(rt, r - l + 1);
int mid = (l + r) >> 1;
if (L <= mid) update(t, q, L, R, l, mid, rt << 1);
if (mid < R) update(t, q, L, R, mid + 1, r, rt << 1 | 1);
pushup(rt);
return;
}
inline ll query(ll t, ll L, ll R, int l, int r, int rt) {//询问
if (L <= l && r <= R) {
if (t == 1)
return tree[rt].sum1;
if (t == 2)
return tree[rt].sum2;
if (t == 3)
return tree[rt].sum3;
}
pushdown(rt, r - l + 1);
int mid = (l + r) >> 1;
ll a = 0, b = 0;
if (L <= mid) a = query(t, L, R, l, mid, rt << 1);
if (mid < R) b = query(t, L, R, mid + 1, r, rt << 1 | 1);
return (a + b) % mod;
}
int main()
{
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
int n, m;
while (~scanf("%d%d", &n, &m)) {
if (n == 0)break;
memset(tree, 0, sizeof tree);
while (m--) {
ll op, x, y, c;
scanf("%lld%lld%lld%lld", &op, &x, &y, &c);
if (op != 4) {
update(c, op, x, y, 1, n, 1);
}
else {
printf("%lld
", query(c, x, y, 1, n, 1));
}
}
}
return 0;
}
区间合并
给你一段区间，询问区间[l,r]中的最长连续区间，这时候就要用到区间合并了。
区间合并线段树的定义：
struct TREE{
int len;//这个节点维护的区间长度
int maxl,maxr,max;
//maxl:区间[l,r]中从l开始的区间的长度
//maxr:区间[l,r]中从r开始的区间的长度
//max:区间[l,r]中的最大长度
}tree[N<<2];
每个节点维护的值可以用下面三张图表示
（待补）
区间合并真正让人难以理解的是区间合并的pushup函数
#define ls rt<<1
#define rs rt<<1|1
void pushup(int rt){
tree[rt].max = max(tree[ls].maxr+tree[rs].maxl, max(tree[ls].maxl,tree[rs].maxr));
tree[rt].maxl = (tree[ls].maxl == tree[ls].len) ? tree[ls].maxl + tree[rs].maxl : tree[ls].maxl;
tree[rt].maxr = (tree[rs].maxr == tree[rs].len) ? tree[rs].maxr + tree[ls].maxr : tree[rs].maxr;
}
解释一下这三个值的维护方式：
> 1、对于tree[rt].max，按照上面三张图的解释就不难理解了，寻找左儿子的左连续区间、右儿子的右连续区间，左儿子右连续区间与右儿子右连续区间之和三者的最大值，就是这个点最大的连续区间。
>2、对于tree[rt].maxl，它虽然可以直接继承左儿子的左连续区间，但是有一个特殊情况，如果左儿子的左连续区间与他的长度相等，那么它有可能可以衔接上右儿子的左连续区间！
>3、对于tree[rt].maxr，同理2
很多人不理解2和3的原因，这里再用一张图解释
（待补）
衔接上右儿子的左连续区间后才是作为父亲的总的左连续区间，这就是区间合并
操作完pushup之后，tree[1].max就是要求的最大连续区间啦~
什么，你想知道[L,R]的最大连续区间？那就写query函数询问吧
int query(int L,int R,int l,int r,int rt){
if(tree[rt].max == 0 || tree[rt].max == r - l + 1) return tree[rt].max;
int mid = (l+r)>>1;
if(l <= mid)return r > mid - tree[rt].maxr ? tree[rt].maxr + tree[rp].maxl : query(L,R,lson);
else return r <= tree[rt].maxl + mid ? tree[tr].maxl + tree[tr].maxr : query(L,R,rson);
}
例题：HDU 4553：约会安排(区间合并)
题意：小明是个屌丝，帮他安排时间规划，题目有点绕，可以去上面的链接看。
题解：我觉得这题不能作为区间合并的板子题，然而集训的时候唯一的一题区间合并居然这么难。。开两棵树分别维护女神时间和屌丝时间，女神时间的优先级大于屌丝时间，给屌丝安排时间的时候只要问屌丝树有没有长度满足就可以了，而给女神安排时间需要先询问女神树，有满足长度的时间再去屌丝树上放屌丝的gezi
#include<iostream>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<string>
#include<string.h>
#include<queue>
#include<functional>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "<<a<<endl
#define dd(a) cout<<#a<<" = "<<a<<" "
#define be begin
#define en end
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int maxn = 100000;
struct TREE {
int len;
int nsmaxr, nsmaxl, nsmax;//屌丝树
int dsmaxr, dsmaxl, dsmax;//女神树
int nslay, dslay, sxlay;//标记，最后一个是学习标记
}tree[maxn << 2];
#define ls rt<<1
#define rs rt<<1|1
#define lson l,mid,ls
#define rson mid+1,r,rs
void ds(int rt) {//屌丝标记操作
tree[rt].dslay = 1;
tree[rt].dsmax = tree[rt].dsmaxl = tree[rt].dsmaxr = 0;
}
void ns(int rt) {//女神标记操作
tree[rt].nslay = 1;
tree[rt].dslay = 0;
tree[rt].dsmax = tree[rt].dsmaxl = tree[rt].dsmaxr = 0;
tree[rt].nsmax = tree[rt].nsmaxl = tree[rt].nsmaxr = 0;
}
void sx(int rt) {//学习标记操作
tree[rt].dslay = tree[rt].nslay = 0;
tree[rt].sxlay = 1;
tree[rt].nsmax = tree[rt].nsmaxl = tree[rt].nsmaxr = tree[rt].len;
tree[rt].dsmax = tree[rt].dsmaxl = tree[rt].dsmaxr = tree[rt].len;
}
void pushup(int rt) {//区间合并
tree[rt].dsmax = max(tree[ls].dsmaxr + tree[rs].dsmaxl, max(tree[ls].dsmax, tree[rs].dsmax));
tree[rt].dsmaxl = (tree[ls].dsmaxl == tree[ls].len) ? tree[ls].dsmaxl + tree[rs].dsmaxl : tree[ls].dsmaxl;
tree[rt].dsmaxr = (tree[rs].dsmaxr == tree[rs].len) ? tree[rs].dsmaxr + tree[ls].dsmaxr : tree[rs].dsmaxr;
tree[rt].nsmax = max(tree[ls].nsmaxr + tree[rs].nsmaxl, max(tree[ls].nsmax, tree[rs].nsmax));
tree[rt].nsmaxl = (tree[ls].nsmaxl == tree[ls].len) ? tree[ls].nsmaxl + tree[rs].nsmaxl : tree[ls].nsmaxl;
tree[rt].nsmaxr = (tree[rs].nsmaxr == tree[rs].len) ? tree[rs].nsmaxr + tree[ls].nsmaxr : tree[rs].nsmaxr;
}
void pushdown(int rt) {//下传标记，同样注意优先级
if (tree[rt].sxlay) {
sx(ls);
sx(rs);
tree[rt].sxlay = 0;
}
if (tree[rt].dslay) {
ds(ls);
ds(rs);
tree[rt].dslay = 0;
}
if (tree[rt].nslay) {
ns(ls);
ns(rs);
tree[rt].nslay = 0;
}
}
void build(int l, int r, int rt) {//建树，初始化
tree[rt].len = r - l + 1;
tree[rt].nslay = tree[rt].dslay = tree[rt].sxlay = 0;
if (l == r) {
tree[rt].dsmax = tree[rt].nsmax = 1;
tree[rt].dsmaxl = tree[rt].nsmaxl = 1;
tree[rt].dsmaxr = tree[rt].nsmaxr = 1;
return;
}
int mid = (l + r) >> 1;
build(lson);
build(rson);
pushup(rt);
return;
}
void update(int op, int L, int R, int l, int r, int rt) {//更新
if (L <= l && r <= R) {
if (op == 2)
sx(rt);
else if (op == 1)
ds(rt);
else ns(rt);
return;
}
pushdown(rt);
int mid = (l + r) >> 1;
if (L <= mid) update(op, L, R, lson);
if (mid < R) update(op, L, R, rson);
pushup(rt);
return;
}
int query(int op, int t, int l, int r, int rt) {//询问是否存在时间，如果存在，返回最早的左时间
if (l == r)
return l;
pushdown(rt);
int mid = (l + r) >> 1;
if (op == 1) {
if (tree[ls].dsmax >= t) return query(op, t, lson);
if (tree[ls].dsmaxr + tree[rs].dsmaxl >= t) return mid - tree[ls].dsmaxr + 1;
return query(op, t, rson);//
}
else {
if (tree[ls].nsmax >= t) return query(op, t, lson);
if (tree[ls].nsmaxr + tree[rs].nsmaxl >= t) return mid - tree[ls].nsmaxr + 1;
return query(op, t, rson);//
}
}
int main()
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int T;
scanf("%d", &T);
for (int i = 1;i <= T;i++) {
int t, n;
printf("Case %d:
", i);
scanf("%d%d", &t, &n);
build(1, t, 1);
while (n--) {
//getchar();
char s[10];
int q;
scanf("%s%d", s, &q);
if (s[0] == 'D') {
if (tree[1].dsmax < q) puts("fly with yourself");
else {
int x = query(1, q, 1, t, 1);
printf("%d,let's fly
", x);
update(1, x, q + x - 1, 1, t, 1);
}
}
else if (s[0] == 'N') {
if(tree[1].dsmax < q){
if (tree[1].nsmax < q) puts("wait for me");
else {
int x = query(0, q, 1, t, 1);
printf("%d,don't put my gezi
", x);
update(0, x, x + q - 1, 1, t, 1);
}
}
else {
int x = query(1, q, 1, t, 1);
printf("%d,don't put my gezi
", x);
update(0, x, x + q - 1, 1, t, 1);
}
}
else {
int r;
scanf("%d", &r);
puts("I am the hope of chinese chengxuyuan!!");
update(2, q, r, 1, t, 1);
}
}
}
return 0;
}
扫描线
在一个二维空间中，求几个随意放置的矩形面积交、面积并、周长并，可以利用扫描线的思想
很多博客解释扫描线是一条只存在脑内的不存在的线，确实扫描线是一个不存在的线，但是我认为把线段树维护的看做是那条线更容易理解扫描线的思想
对扫描线的深入理解
我们先定义扫描线为一棵线段树维护的线段，它维护的值是对应区间中矩形的数量。那么求解这一类问题，就要先搞定矩形数量与边的关系。假设扫描线从下往上扫，遇到矩形的边就停下来进行一次更新和计算，那么n个矩形就会遇到2*n条边(很显然)，这些边我们把底部称为入边，扫描线经过这条边就说明边对应区间上的矩阵数量+1，就把线段树上相应区间标记+1，然后再把顶部称为出边，扫描线经过这里说明这条边上对应区间的矩阵数量-1，就把线段树上相应区间标记-1。这样就可以记录当前边上存在的矩阵数量了，当矩阵数量>=1就可以计算面积并，>=2就可以计算面积交，周长并就上下左右扫两次，遇到边的数量==1记录区间长度就好了。
例题：HDU 1255：覆盖的面积（离散化 + 扫描线）
题意：四个字，求面积交（扫描线板子题）,由于涉及浮点数，而线段树不能处理浮点区间，需要离散化
#include<iostream>
#include<stack>
#include<vector>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>
#include<string>
#include<string.h>
#include<queue>
#include<functional>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i=(a); i<(b); i++)
#define sz(a) (int)a.size()
#define de(a) cout<<#a<<" = "<<a<<endl
#define dd(a) cout<<#a<<" = "<<a<<" "
#define be begin
#define en end
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
struct Line {
double x, X, y;//起点，终点，高度
int flag;//入边+1，出边-1
void in(double a, double b, double c, int f) { x = a, X = b, y = c, flag = f; };
bool operator<(const Line &b) const {
return y<b.y;
}
}line[2010];//边
const int L = 100005;//扫描线长度
struct TREE {
double sum1, sum2;//至少覆盖1次/2次的长度
int lay;//覆盖层数
}tree[L << 2];//扫描线
double S[2020];//离散化
const double eps = 1e-9;
void pushup(int l, int r, int rt) {//扫描线的上传，重点
if (tree[rt].lay > 1)
tree[rt].sum2 = tree[rt].sum1 = S[r + 1] - S[l];
else if (tree[rt].lay == 1) {
tree[rt].sum1 = S[r + 1] - S[l];
if (l == r) tree[rt].sum2 = 0;
else tree[rt].sum2 = tree[rt << 1].sum1 + tree[rt << 1 | 1].sum1;
}
else {
if (l == r) tree[rt].sum1 = tree[rt].sum2 = 0;
else {
tree[rt].sum1 = tree[rt << 1].sum1 + tree[rt << 1 | 1].sum1;
tree[rt].sum2 = tree[rt << 1].sum2 + tree[rt << 1 | 1].sum2;
}
}
}
void update(int v, int L, int R, int l, int r, int rt) {//更新
if (L <= l && r <= R) {
tree[rt].lay += v;
pushup(l, r, rt);
return;
}
int mid = (l + r) >> 1;
if (L <= mid) update(v, L, R, l, mid, rt << 1);
if (R > mid) update(v, L, R, mid + 1, r, rt << 1 | 1);
pushup(l, r, rt);
return;
}
int main()
{
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
int T;
scanf("%d", &T);
while (T--) {
int n;
memset(tree, 0, sizeof tree);
scanf("%d", &n);
rep(i, 1, n+1) {
double x, y, X, Y;
scanf("%lf%lf%lf%lf", &x, &y, &X, &Y);
line[i].in(x, X, y, 1), line[n + i].in(x, X, Y, -1);
S[i] = x, S[n + i] = X;
}
n <<= 1;
sort(S + 1, S + n + 1);
sort(line + 1, line + n + 1);
int s = unique(S + 1, S + n + 1) - (S + 1);
double sum = 0;
for (int i = 0;i < n - 1;i++) {
int l = lower_bound(S + 1, S + s + 1, line[i].x) - S;
int r = lower_bound(S + 1, S + s + 1, line[i].X) - S;
if(l < r) update(line[i].flag, l, r-1, 1, L, 1);
sum += tree[1].sum2*(line[i+1].y - line[i].y);
}
printf("%.2lf
", sum);
}
return 0;
}
小记
花了三天时间学习线段树（入门），觉得线段树是真的强大，但是代码量也不小，对于一些简单的任务分块和树状数组同样可以胜任相同的工作，但是你爹终究是你爸爸，想要实现更强大的算法少不了代码，也算是另一种以空间换时间的概念吧（还有敲代码的时间）。关于线段树还有主席树等更多的拓展，摸了摸自己日益稀疏的头，不知道还能撑多久。