visión de conjunto
árbol segmento es un árbol de búsqueda binaria, cada nodo del árbol son el mantenimiento de información de intervalo, el segmento nodo raíz segmento de información se puede calcular mediante la información subárbol izquierdo y subárbol derecho de la gama que estamos hablando de la satisfacción de adición (es decir, ).
Varios intervalo sumador común: número total de suma digital una sección digital una sección derecha + = e izquierdo y
El gcd Total = gcd (izquierda, derecha)
Número total de multiplicación gama de productos * = izquierda y derecha gama de productos
Total máxima = max (izquierda intervalo máximo y el valor máximo intervalo derecha) // Del mismo modo mínimo
Es lo que sirve? Se puede resolver el rango problema, la consulta puede ser un solo punto en el registro de tiempo (n), el intervalo de consulta, modificar, etc. un único punto, por ejemplo, el título que da una secuencia de longitud n, las operaciones k requerida, cada operación pueden cambiar el valor de un punto, también se puede comprobar el intervalo de L a R, y, si hay una sola consulta y se puede usar el prefijo, más el prefijo y modificar a morir, si la violencia lo hacen en la complejidad de consulta es O (nk), pero Si un árbol segmento puede ser optimizado para O (klogn).
Lo que parece? ¿Cómo hacerlo?
Para la longitud de un segmento de mantenimiento de los árboles 8, es la idea de la forma larga de esta manera:
El rango total es, naturalmente, 1-8, ¿por qué la sección izquierda es un 1-4 la sección derecha es de 5 a 8, porque el árbol de segmentos de núcleo es la naturaleza bipartita, intervalo [L, R] del intervalo izquierda [L, m] la sección derecha es [m + 1, R], m es (L + R) / 2. M Debe tenerse en cuenta que el punto final pertenece a la sección izquierda.
Entonces, si el valor real asignado a él, para decirle ocho cifras fueron 12.345.678, es la situación real tanto tiempo:
Si la referencia a la misma, cada una de las capas de arriba a abajo, de izquierda a derecha para pequeñas y grandes números, se puede ver, cuando n número del nodo raíz, el subárbol izquierdo No. 2 * n, 2 es un subárbol derecho * n + 1:
¿Cómo qué existe? Utilice una matriz para almacenar, a [i] representa la información de la etiqueta para el nodo i, a continuación, abre sea la matriz? matriz espacial 1 sea el número de nodos, para ese segmento línea de árboles de longitud n, el número de nodos que?
Cuando n es una potencia de 2, entonces el árbol de segmento es un árbol binario completo, que es el número de capas de registro 2 (n) hecho +1, entonces el número de nodos es de dos capas -1 es decir, 2n-1, donde n no es una potencia de 2 cuando el árbol segmento será no tan bueno de aspecto, una matriz de nodos de hoja espacio no son necesariamente contiguos:
El árbol segmento n = por ejemplo, 10:
Se puede ver que no es el número total de binario, árbol binario completo de n para llegar a 16, si el número de espacios abiertos 2n-1 también es de 19, de acuerdo con la fórmula anterior, sino más bien el índice máximo real fue a 25, no se puede cumplir, por lo que estaba abierto más grande, a la potencia de N no es un 2, hacemos una capa extra de espacio abierto, es decir n = 10 n = espacio que abrimos 16, n = 17 n = espacio que abrimos 32 , log 2 (n) hecho +1 n es el número de capas para la potencia de 2, con el fin de facilitar no si n es una potencia de 2, tenemos una multi-capa de espacio abierto para ella, por lo que el número de capas log = 2 (n) + 1 + 1, el número total de nodos de la apertura 2 log 2 (n-) + 1 + 1 -1, es decir, 4n-1, 4 línea de plegado de manera que la abertura, completa la demostración!
línea de árboles ordinaria detallado de código
Para abrir las variables: maxN es el alcance máximo de n, A [maxN] valor tema n información de almacenamiento, correspondiente a la hoja del árbol de segmento de nodo a [4 * maxN] es el segmento espacial del árbol, el nodo de referencia es i.
Para obtener información nodo de mantenimiento
Nota qué información se almacena nodo, este código se almacena y rango:
void pushup ( int rt) { un [RT] = a [rt << 1 ] + a [rt << 1 | 1 ]; }
contribuir
建树的过程就是一直递归到叶子节点，然后把当前编号的空间赋值为对应题目的信息，在递归结束的时候要维护区间信息
1 void build(int l,int r,int rt){//对于 l 到 r 的一颗线段树建树 2 if(l==r){//代表已经递归到叶子节点 3 a[rt]=A[l]; 4 return ; 5 } 6 int m=l+r>>1; 7 build(l,m,rt<<1);//建左子树 8 build(m+1,r,rt<<1|1);//建右子树 9 pushup(rt);//左右子树建好之后维护当前区间的信息 10 }
单点更新
单点更新其实就是一个找叶子节点编号的二分过程，当你找到对应叶子节点的位置，你想干嘛干嘛，这里是对应位置加上val值：
1 void update(int pos,int val,int l,int r,int rt){//在pos位置加上val 2 if(l==r){//代表已经递归到叶子节点 3 a[rt]+=val; 4 return; 5 } 6 int m=l+r>>1; 7 if(pos<=m)//目标位置在左边 8 update(pos,val,l,m,rt<<1); 9 else//在右边 10 update(pos,val,m+1,r,rt<<1|1); 11 pushup(rt);//更新完维护信息 12 }
单点查询
单点查询其实和单点更新本质上相同，就是找到叶子节点，然后想干嘛干嘛
int search(int pos,int l,int r,int rt){ if(l==r){ return a[rt]; } int m=l+r>>1; if(pos<=m) return search(pos,l,m,rt<<1); else return search(pos,m+1,r,rt<<1|1); }
区间查询
在区间查询中，有两个区间，一个是查询区间我们设为【L，R】，一个是递归区间设为【l，r】。假如我们要查询区间和，设为ans。
1 int query(int L,int R,int l,int r,int rt){ 2 if(L<=l&&r<=R){ 3 return a[rt];//第一种情况，直接贡献 4 } 5 int m=l+r>>1; 6 int ans=0; 7 if(L<=m)//递归区间的左边含有查询 8 ans+=query(L,R,l,m,rt<<1); 9 if(R>m) 10 ans+=query(L,R,m+1,r,rt<<1|1); 11 return ans;//统计二三情况的贡献，返回最终值 12 }
分三种情况:
一是递归区间属于查询区间，L<=l&&r<=R，就是说本节点所表示的信息你全部都要，那就贡献到ans里。
二是递归区间的左边有查询区间，L<=m,但本节点信息你不是全部要，得递归深一点，直到满足情况一才贡献ans，遂令下一个递归区间为【l,m】。
三是递归区间的右边有查询区间，R>m,但本节点信息你不是全部要，得递归深一点，直到满足情况一才贡献ans，遂令下一个递归区间为【R,m+1】。
区间更新
假如我们要将区间【L，R】中的每一个端点加上一个值val，如果区间更新用R-L+1个单点更新来做，那么复杂度要去到O(长度*logn)，那么最坏长度为整个序列那么长，就是nlogn了。为了降低时间复杂度，我们引入懒标记这一概念。
每一个节点都有一个懒标记值，懒标记——表示本节点的左右子树有区间更新需求但尚未更新。懒标记顾名思义就是太懒了，懒得递归下去，打个标记，之后如果要用到就顺便更新了。
举个例子，对于n=10，各个端点值为1 2 3 4 5 6 7 8 9 10，