線段樹原理
線段樹是一顆二叉樹,他的每個節點對應的都是一個區間,主要是通過對區間的分割和合並來修改節點的值, 然後再得到答案。
現在給你一個 目的爲求區間和 所造出來的線段樹 線段樹。如下圖所示。
仔細觀察,第一二三行方框內的值是他的下面2個子區間的和, 第四行的方框內的數字代表的是自身的值, 藍色代表的是這個方框他包含的區間, 紅色代表的是這個元素在數組中所儲存的位置。(在絕大多數博客中,我們默認區間的左兒子他的下標是當前區間下標的2倍,右兒子的下標是當前區間的2倍再加上1,這個下標是認爲定義的,你也可以將對應關係修改)。
爲什麼說用線段樹可以節省求和時間呢, 假設我們需要查找區間 [1,8] 的和, 對於這個不用多說, 我們可以直接將最上面的那個46輸出,因爲最上面的那個矩形代表的就是區間 [1,8] 的和。
然後假設我們要查找區間 [3,7] 的和, 剛開始我們出現在區間 [1,8]的位置, 但是對於目標區間來說 [1,8] 太大了, 所以我們要繼續往下走, 走到 [1,4] 和 [5,8] 的區間, 但是對於這2個區間來說, 還有一部分區域是落在查詢區間之外的, 所以我們需要繼續往下走,我們先分析區間 [1,4] , 對於他左兒子的區間[1,2]來說,沒有任意一個點是落在查詢區間內的, 所以我們不需要走到他的左兒子處, 然後走到右兒子[3,4],可以發現 [3,4] 倍查詢區間覆蓋了, 所以我們就不需要往下走了, 因爲整個區間都倍覆蓋了, 直接將這個點的值返回就好了, 因爲這個點就是他下面節點的和。 然後我們再看區間[5,8], 先往左走, 走到左兒子區間 [5,6] ,也可以發現該區間倍查詢區間覆蓋了,就不需要往下走了, 返回該節點的值,對於右兒子節點 [7,8] 來說,只有一部分區域倍查詢區間覆蓋, 所以我們還需要往下走,繼續往左邊走, 發現 [7,7] 是合法區域, 返回該值, {8,8]不是合法區域,所以不對這快裏的數據進行處理。 所以最後的結果就是 [3,4] + [5,6] + [7,7] 這3個區間的和。 可能你會說就5個點而已, 我直接加過去時間也就這樣, 的確, 當點數小的時候線段樹的優勢並不會很明顯,但是如果查詢的區間長度會到達 1e5的話, 那麼線段樹就可以省下很多時間了。
線段樹的某段區間內的值是可以修改的。
假設我們修改了區間[2,2]的值
我們就需要更新一下所有區間內含2的區間, 也就是順着[2,2]一直往上走 按次序更新 [2,2] -> [1,2] -> [1,4] -> [1,8] 這四個區間的值, 更新完了之後就可以繼續愉快的去查詢區間和了。
可以發現, 每一次對於一個點更新之後, 她執行的點的數目就是logn個, 如果你使用的是前綴和去寫的話, 就需要約更新n 個節點。
代碼實現
1,建樹,對於一顆樹需要先建樹。這裏用到的是遞歸建樹。
1
void Build(int l, int r, int rt){ // l,r 代表的是這個區間內的左端點 和 右端點, rt代表的是 [l,r] 這個區間內的值是存在哪一個位置的。
if(l == r){
scanf("%d", tree[rt]); /// tree[rt] = a[l];
return ;
}
int m = (l+r) / 2;
Build(l,m,rt*2); // 對於區間區分,我們一般將m點劃入左半邊區間
Build(m+1,r,rt*2+1);
PushUp(rt); // PushUp 函數是通過2個子節點來更新現在這個節點的狀態, 對於不同的要求需要不同的寫法。
}
2,通過子節點來更新目前節點。
void PushUp(int rt){
tree[rt] = tree[rt*2] + tree[rt*2+1]; ///區間和的更新操作
}
void PushUp(int rt){
tree[rt] = max(tree[rt*2], tree[rt*2+1]);///求區域最大值的更新操作
}
3,更新某個節點。
void Update(int l, int r, int rt, int L, int C){ // l,r,rt 與前面的定義一樣, L代表的是要更新區間的位置,C代表的是修改後的值
if(l == r){ /// 這裏不能寫成 if(l == L) 因爲有可能左端點恰好是要更新的位置, 但是還有右端點, 我們直接更新的只有區間 [L,L]。
tree[rt] = C;
return ;
}
int m = (l+r) / 2;
if(L <= m) Update( l, m, rt*2, L, C); //要更新的區間在左邊部分,所以往左邊走,更新左邊
else Update(m+1, r, rt*2+1, L, C); //要更新的區間在右邊部分, 往右邊走,更新右邊
PushUp(rt); //更新完子節點之後需要更新現在的位置, 需要保證線段樹的性質。
}
4, 查詢區間和
查詢的規則前面已經解釋過一次了。
int Query(int l, int r, int rt, int L, int R){// [L,R]爲查詢區間
if(L <= l && r <= R){ // 如果成立則滿足查詢區間覆蓋了當前區間, 直接返回當前區間的值
return tree[rt];
}
int m = (l+r) / 2;
int ret = 0;
if(L <= m) ret += Query(l, m, rt*2, L, R); //左邊有一部分需要查詢的區域。
if(m < R) ret += Query(m+1, r, rt*2+1, L, R);//右邊有一部分。
return ret;
}
https://blog.csdn.net/weixin_43272781/article/details/83417979
https://blog.csdn.net/weixin_43272781/article/details/83418406
總結
1。首先對於大多數線段樹題目來說, 第一步就是建樹。 建樹用法 Build(1,n,1), [1,n]就是第一個節點所代表的區間長度。
2。在每次更新了點之後,爲了保證線段樹性質, 一定要去執行PushUP操作,保證線段樹的性質不丟失。
3。線段樹的精華就是,每一個節點代表着一段區間,這個節點的值,就是他所代表的區間內的值。
4。當底層節點只有5個點的時候, 我們處理線段樹時, 需要將他變成8個節點, 如果給9個節點, 那麼底層節點必須要有16個節點, 所以爲了保證空間足夠用,所以需要將空間開大2倍,然後由於每一層的上方都還有 m/2個點(m爲該層節點的數目)。
所以空間需要再大兩倍, 最終合起來就是4倍。 所以我們需要開 4n 的空間。
區間更新 lazy標記
現在我們突然遇到這樣一個題目
A Simple Problem with Integers
Time Limit: 5000MS | Memory Limit: 131072K | |
Total Submissions: 144801 | Accepted: 44993 | |
Case Time Limit: 2000MS |
Description
You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.
Input
The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A1, A2, ... , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of Aa, Aa+1, ... , Ab. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of Aa, Aa+1, ... , Ab.
Output
You need to answer all Q commands in order. One answer in a line.
Sample Input
10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4
Sample Output
4
55
9
15
Hint
The sums may exceed the range of 32-bit integers.
這個題目和上面題目不同的地方是更新, 在這個題目中, 他更新數據是成段更新, 上面的題目都是一個點一個點更新, 並且更新的次數不是很少, 我們不可能去像點更新一樣, 將這些區域內的點都一個個更新過去。
前面提到過,線段樹的每一個節點都代表着一段區間的性質, 所以假如我們需要對於區間 [5,8] 裏面的數都加上 10。(基於更新[2,2]後的那個線段樹)。
如果我們將一個個點覆蓋過去之後, 現在的這課樹是這樣的。
我們可以發現對節點3來說, 他所管轄的區間[5,8]都是要被更新的區間,並且他增加的指爲40,即 區間長度(4) * 修改的值(10)。 我們可以發現,在區域更新的時候, 對於一個節點來說, 如果他所管理的區間 被 要更新的區間 覆蓋了, 那我們就提早了知道這一個節點的值。
然後我們引入一個概念, lazy標記, 還是對於開頭的情況來說, 如果我們使用了lazy標記之後, 這一課線段樹是這樣的
在這一顆樹上, 我們只修改了2個節點, 同時在節點3處增加了一個 lazy標記, 在這個標記中 lazy = 10。(即整段區間內每一個點都要加上的值)。接下來, 我們如果詢問區間[1,8]的和, 我們直接返回節點1就好了。 如果我們詢問區間 [3,8] 的和 那麼只需要返回 [3,4] + [5,8] 的值。 我們可以看見如果不訪問[5,8]的子區間的時候, 我並不會用到裏面的值。 在這些時候, 我們並不需要更新裏面的值, 更不更新都一樣, 不會被訪問到。
如果我們現在需要查詢 [1,5]的和, 我們只需要將 lazy 標記下推,然後再更新對應的區間就好了。
然後我們返回 [1,4] + [5,5] 的值就好了。
總結就是:
lazy標記的含義就是延遲更新,在我們不需要訪問區間內部時就保留lazy標記的值,如果需要訪問內部的時候,我們要先將lazy標記下推, 因爲可能lazy標記還需要繼續往下走。
在區域更新的時候,如果 當前區間 被 更新的區間完全覆蓋了, 就直接在這個節點加上 區間長度*修改的值, 並且更新這個點的lazy標記。
操作代碼:
PushDown --- 將lazy標記下推
void PushDown(int rt, int llen, int rlen){
if(lazy[rt]){
lazy[rt*2] += lazy[rt];
lazy[rt*2+1] += lazy[rt];
tree[rt*2] += lazy[rt] * llen;
tree[rt*2+1] += lazy[rt] * rlen;
lazy[rt] = 0;
}
}
void Update(int l, int r, int rt, int L, int R, int C){
if(L <= l && r <= R){
tree[rt] += (LL)C*(r-l+1);
lazy[rt] += C;
return;
}
int m = (l+r) / 2;
PushDown(rt, m-l+1, r-m);
if(L <= m) Update(l, m, rt*2, L, R, C);
if(m < R) Update(m+1, r, rt*2+1, L, R, C);
PushUp(rt);
}
LL Query(int l, int r, int rt, int L, int R){
if(L <= l && r <= R) return tree[rt];
LL ans = 0;
int m = (l+r) / 2;
PushDown(rt, m-l+1, r-m);
if(L <= m) ans += Query(l, m, rt*2, L, R);
if(m < R) ans += Query(m+1, r, rt*2+1, L, R);
return ans;
}
注意的就是每次對子區間進行修改的時候,我們都需要提前先把lazy標記下推。
#include<cstdio>
#define LL long long
const int N = 1e5+10;
LL tree[N<<2];
LL lazy[N<<2];
int a[N];
void PushUp(int rt){
tree[rt] = tree[rt*2] + tree[rt*2+1];
}
void PushDown(int rt, int llen, int rlen){
if(lazy[rt]){
lazy[rt*2] += lazy[rt];
lazy[rt*2+1] += lazy[rt];
tree[rt*2] += lazy[rt] * llen;
tree[rt*2+1] += lazy[rt] * rlen;
lazy[rt] = 0;
}
}
void Build(int l, int r, int rt){
lazy[rt] = 0;
if(l == r){
tree[rt] = a[l];
return ;
}
int m = (l+r) / 2;
Build(l, m, rt*2);
Build(m+1, r, rt*2+1);
PushUp(rt);
}
void Update(int l, int r, int rt, int L, int R, int C){
if(L <= l && r <= R){
tree[rt] += (LL)C*(r-l+1);
lazy[rt] += C;
return;
}
int m = (l+r) / 2;
PushDown(rt, m-l+1, r-m);
if(L <= m) Update(l, m, rt*2, L, R, C);
if(m < R) Update(m+1, r, rt*2+1, L, R, C);
PushUp(rt);
}
LL Query(int l, int r, int rt, int L, int R){
if(L <= l && r <= R) return tree[rt];
LL ans = 0;
int m = (l+r) / 2;
PushDown(rt, m-l+1, r-m);
if(L <= m) ans += Query(l, m, rt*2, L, R);
if(m < R) ans += Query(m+1, r, rt*2+1, L, R);
return ans;
}
int main(){
int n, m, i, j, c;
char str[N];
while(~scanf("%d%d", &n, &m)){
for(int i = 1; i <= n; i++)
scanf("%d", &a[i]);
Build(1, n, 1);
while(m--){
scanf("%s", str);
if(str[0] == 'Q'){
scanf("%d%d", &i, &j);
printf("%lld\n", Query(1,n,1,i,j));
}
else if(str[0] == 'C'){
scanf("%d%d%d", &i, &j, &c);
Update(1,n,1,i,j,c);
}
}
}
return 0;
}
https://blog.csdn.net/weixin_43272781/article/details/83419816