Dato un array arr[0..N-1]. È necessario eseguire le seguenti operazioni.
- aggiornamento(l r val) : Aggiungi "val" a tutti gli elementi nell'array da [l r].
- getRangeSum(l r) : Trova la somma di tutti gli elementi nell'array da [l r].
Inizialmente tutti gli elementi nell'array sono 0. Le query possono essere in qualsiasi ordine, ovvero possono esserci molti aggiornamenti prima della somma dell'intervallo.
Esempio:
Ingresso: N = 5 // {0 0 0 0 0}
Domande: aggiornamento: l = 0 r = 4 val = 2
aggiornamento: l = 3 r = 4 val = 3
getRangeSum: l = 2 r = 4Produzione: La somma degli elementi dell'intervallo [2 4] è 12
Spiegazione: L'array dopo il primo aggiornamento diventa {2 2 2 2 2}
L'array dopo il secondo aggiornamento diventa {2 2 2 5 5}
Approccio ingenuo: Per risolvere il problema seguire l'idea seguente:
Nel messaggio precedente abbiamo discusso l'aggiornamento della gamma e le soluzioni di query dei punti utilizzando BIT.
rangeUpdate(l r val): aggiungiamo 'val' all'elemento nell'indice 'l'. Sottraiamo 'val' dall'elemento all'indice 'r+1'.
getElement(index) [o getSum()]: restituiamo la somma degli elementi da 0 all'indice che può essere rapidamente ottenuto utilizzando BIT.
Possiamo calcolare rangeSum() utilizzando le query getSum().
rangeSum(l r) = getSum(r) - getSum(l-1)js impostatoUna soluzione semplice è utilizzare le soluzioni discusse nel messaggio precedente . La query di aggiornamento dell'intervallo è la stessa. La query sulla somma dell'intervallo può essere ottenuta eseguendo una query get per tutti gli elementi nell'intervallo.
Approccio efficiente: Per risolvere il problema seguire l'idea seguente:
Otteniamo la somma dell'intervallo utilizzando le somme dei prefissi. Come assicurarsi che l'aggiornamento venga eseguito in modo tale che la somma del prefisso possa essere eseguita rapidamente? Considera una situazione in cui la somma del prefisso [0 k] (dove 0<= k < n) is needed after range update on the range [l r]. Three cases arise as k can possibly lie in 3 regions.
- Caso 1 : 0< k < l
- La query di aggiornamento non influirà sulla query di somma.
- Caso 2 : l<= k <= r
- Considera un esempio: Aggiungi 2 all'intervallo [2 4] l'array risultante sarebbe: 0 0 2 2 2
Se k = 3 La somma di [0 k] = 4Come ottenere questo risultato?
Basta aggiungere la val da lthindice a kthindice. La somma viene incrementata di "val*(k) - val*(l-1)" dopo la query di aggiornamento.
- Caso 3 : k > r
- In questo caso dobbiamo aggiungere 'val' da lthindice a rthindice. La somma viene incrementata di 'val*r – val*(l-1)' a causa di una query di aggiornamento.
Osservazioni:
Caso 1: è semplice in quanto la somma rimarrebbe la stessa di prima dell'aggiornamento.
Caso 2: La somma è stata incrementata di val*k - val*(l-1). Possiamo trovare 'val' è simile a trovare ithelemento dentro articolo sull'aggiornamento dell'intervallo e sulla query dei punti . Quindi manteniamo un BIT per l'aggiornamento dell'intervallo e le query sui punti, questo BIT sarà utile per trovare il valore in kthindice. Ora val * k viene calcolato come gestire il termine extra val*(l-1)?
Per gestire questo termine aggiuntivo manteniamo un altro BIT (BIT2). Aggiorna val * (l-1) a lthindice in modo che quando la query getSum viene eseguita su BIT2 fornirà il risultato come val*(l-1).
Caso 3: La somma nel caso 3 è stata incrementata di 'val*r - val *(l-1)' il valore di questo termine può essere ottenuto utilizzando BIT2. Invece di aggiungere sottraiamo 'val*(l-1) - val*r' poiché possiamo ottenere questo valore da BIT2 aggiungendo val*(l-1) come abbiamo fatto nel caso 2 e sottraendo val*r in ogni operazione di aggiornamento.
Aggiorna domanda
Aggiornamento (BITree1 l val)
Aggiorna(BITree1 r+1 -val)
AggiornaBIT2(BITree2 l val*(l-1))
AggiornaBIT2(BITree2 r+1 -val*r)Somma intervallo
getSum(BITTree1 k) *k) - getSum(BITTree2 k)
sistema operativo di rete
Seguire i passaggi seguenti per risolvere il problema:
- Crea i due alberi di indici binari utilizzando la funzione data buildBITree()
- Per trovare la somma in un determinato intervallo, chiamare la funzione rangeSum() con parametri come l'intervallo specificato e alberi indicizzati binari
- Chiama una funzione somma che restituirà una somma nell'intervallo [0 X]
- Restituisce somma(R) - somma(L-1)
- All'interno di questa funzione chiama la funzione getSum() che restituirà la somma dell'array da [0 X]
- Restituisce getSum(Albero1 x) * x - getSum(albero2 x)
- All'interno della funzione getSum() crea una somma intera uguale a zero e aumenta l'indice di 1
- Mentre l'indice è maggiore di zero aumentare la somma di Tree[index]
- Diminuire l'indice di (indice & (-indice)) per spostare l'indice sul nodo genitore nell'albero
- Restituisci la somma
- Stampa la somma nell'intervallo indicato
Di seguito è riportata l’implementazione dell’approccio di cui sopra:
C++// C++ program to demonstrate Range Update // and Range Queries using BIT #include
// Java program to demonstrate Range Update // and Range Queries using BIT import java.util.*; class GFG { // Returns sum of arr[0..index]. This function assumes // that the array is preprocessed and partial sums of // array elements are stored in BITree[] static int getSum(int BITree[] int index) { int sum = 0; // Initialize result // index in BITree[] is 1 more than the index in // arr[] index = index + 1; // Traverse ancestors of BITree[index] while (index > 0) { // Add current element of BITree to sum sum += BITree[index]; // Move index to parent node in getSum View index -= index & (-index); } return sum; } // Updates a node in Binary Index Tree (BITree) at given // index in BITree. The given value 'val' is added to // BITree[i] and all of its ancestors in tree. static void updateBIT(int BITree[] int n int index int val) { // index in BITree[] is 1 more than the index in // arr[] index = index + 1; // Traverse all ancestors and add 'val' while (index <= n) { // Add 'val' to current node of BI Tree BITree[index] += val; // Update index to that of parent in update View index += index & (-index); } } // Returns the sum of array from [0 x] static int sum(int x int BITTree1[] int BITTree2[]) { return (getSum(BITTree1 x) * x) - getSum(BITTree2 x); } static void updateRange(int BITTree1[] int BITTree2[] int n int val int l int r) { // Update Both the Binary Index Trees // As discussed in the article // Update BIT1 updateBIT(BITTree1 n l val); updateBIT(BITTree1 n r + 1 -val); // Update BIT2 updateBIT(BITTree2 n l val * (l - 1)); updateBIT(BITTree2 n r + 1 -val * r); } static int rangeSum(int l int r int BITTree1[] int BITTree2[]) { // Find sum from [0r] then subtract sum // from [0l-1] in order to find sum from // [lr] return sum(r BITTree1 BITTree2) - sum(l - 1 BITTree1 BITTree2); } static int[] constructBITree(int n) { // Create and initialize BITree[] as 0 int[] BITree = new int[n + 1]; for (int i = 1; i <= n; i++) BITree[i] = 0; return BITree; } // Driver Program to test above function public static void main(String[] args) { int n = 5; // Contwo BIT int[] BITTree1; int[] BITTree2; // BIT1 to get element at any index // in the array BITTree1 = constructBITree(n); // BIT 2 maintains the extra term // which needs to be subtracted BITTree2 = constructBITree(n); // Add 5 to all the elements from [04] int l = 0 r = 4 val = 5; updateRange(BITTree1 BITTree2 n val l r); // Add 10 to all the elements from [24] l = 2; r = 4; val = 10; updateRange(BITTree1 BITTree2 n val l r); // Find sum of all the elements from // [14] l = 1; r = 4; System.out.print('Sum of elements from [' + l + '' + r + '] is '); System.out.print(rangeSum(l r BITTree1 BITTree2) + 'n'); } } // This code is contributed by 29AjayKumar
# Python3 program to demonstrate Range Update # and Range Queries using BIT # Returns sum of arr[0..index]. This function assumes # that the array is preprocessed and partial sums of # array elements are stored in BITree[] def getSum(BITree: list index: int) -> int: summ = 0 # Initialize result # index in BITree[] is 1 more than the index in arr[] index = index + 1 # Traverse ancestors of BITree[index] while index > 0: # Add current element of BITree to sum summ += BITree[index] # Move index to parent node in getSum View index -= index & (-index) return summ # Updates a node in Binary Index Tree (BITree) at given # index in BITree. The given value 'val' is added to # BITree[i] and all of its ancestors in tree. def updateBit(BITTree: list n: int index: int val: int) -> None: # index in BITree[] is 1 more than the index in arr[] index = index + 1 # Traverse all ancestors and add 'val' while index <= n: # Add 'val' to current node of BI Tree BITTree[index] += val # Update index to that of parent in update View index += index & (-index) # Returns the sum of array from [0 x] def summation(x: int BITTree1: list BITTree2: list) -> int: return (getSum(BITTree1 x) * x) - getSum(BITTree2 x) def updateRange(BITTree1: list BITTree2: list n: int val: int l: int r: int) -> None: # Update Both the Binary Index Trees # As discussed in the article # Update BIT1 updateBit(BITTree1 n l val) updateBit(BITTree1 n r + 1 -val) # Update BIT2 updateBit(BITTree2 n l val * (l - 1)) updateBit(BITTree2 n r + 1 -val * r) def rangeSum(l: int r: int BITTree1: list BITTree2: list) -> int: # Find sum from [0r] then subtract sum # from [0l-1] in order to find sum from # [lr] return summation(r BITTree1 BITTree2) - summation( l - 1 BITTree1 BITTree2) # Driver Code if __name__ == '__main__': n = 5 # BIT1 to get element at any index # in the array BITTree1 = [0] * (n + 1) # BIT 2 maintains the extra term # which needs to be subtracted BITTree2 = [0] * (n + 1) # Add 5 to all the elements from [04] l = 0 r = 4 val = 5 updateRange(BITTree1 BITTree2 n val l r) # Add 10 to all the elements from [24] l = 2 r = 4 val = 10 updateRange(BITTree1 BITTree2 n val l r) # Find sum of all the elements from # [14] l = 1 r = 4 print('Sum of elements from [%d%d] is %d' % (l r rangeSum(l r BITTree1 BITTree2))) # This code is contributed by # sanjeev2552
// C# program to demonstrate Range Update // and Range Queries using BIT using System; class GFG { // Returns sum of arr[0..index]. This function assumes // that the array is preprocessed and partial sums of // array elements are stored in BITree[] static int getSum(int[] BITree int index) { int sum = 0; // Initialize result // index in BITree[] is 1 more than // the index in []arr index = index + 1; // Traverse ancestors of BITree[index] while (index > 0) { // Add current element of BITree to sum sum += BITree[index]; // Move index to parent node in getSum View index -= index & (-index); } return sum; } // Updates a node in Binary Index Tree (BITree) at given // index in BITree. The given value 'val' is added to // BITree[i] and all of its ancestors in tree. static void updateBIT(int[] BITree int n int index int val) { // index in BITree[] is 1 more than // the index in []arr index = index + 1; // Traverse all ancestors and add 'val' while (index <= n) { // Add 'val' to current node of BI Tree BITree[index] += val; // Update index to that of // parent in update View index += index & (-index); } } // Returns the sum of array from [0 x] static int sum(int x int[] BITTree1 int[] BITTree2) { return (getSum(BITTree1 x) * x) - getSum(BITTree2 x); } static void updateRange(int[] BITTree1 int[] BITTree2 int n int val int l int r) { // Update Both the Binary Index Trees // As discussed in the article // Update BIT1 updateBIT(BITTree1 n l val); updateBIT(BITTree1 n r + 1 -val); // Update BIT2 updateBIT(BITTree2 n l val * (l - 1)); updateBIT(BITTree2 n r + 1 -val * r); } static int rangeSum(int l int r int[] BITTree1 int[] BITTree2) { // Find sum from [0r] then subtract sum // from [0l-1] in order to find sum from // [lr] return sum(r BITTree1 BITTree2) - sum(l - 1 BITTree1 BITTree2); } static int[] constructBITree(int n) { // Create and initialize BITree[] as 0 int[] BITree = new int[n + 1]; for (int i = 1; i <= n; i++) BITree[i] = 0; return BITree; } // Driver Code public static void Main(String[] args) { int n = 5; // Contwo BIT int[] BITTree1; int[] BITTree2; // BIT1 to get element at any index // in the array BITTree1 = constructBITree(n); // BIT 2 maintains the extra term // which needs to be subtracted BITTree2 = constructBITree(n); // Add 5 to all the elements from [04] int l = 0 r = 4 val = 5; updateRange(BITTree1 BITTree2 n val l r); // Add 10 to all the elements from [24] l = 2; r = 4; val = 10; updateRange(BITTree1 BITTree2 n val l r); // Find sum of all the elements from // [14] l = 1; r = 4; Console.Write('Sum of elements from [' + l + '' + r + '] is '); Console.Write(rangeSum(l r BITTree1 BITTree2) + 'n'); } } // This code is contributed by 29AjayKumar
<script> // JavaScript program to demonstrate Range Update // and Range Queries using BIT // Returns sum of arr[0..index]. This function assumes // that the array is preprocessed and partial sums of // array elements are stored in BITree[] function getSum(BITreeindex) { let sum = 0; // Initialize result // index in BITree[] is 1 more than the index in arr[] index = index + 1; // Traverse ancestors of BITree[index] while (index > 0) { // Add current element of BITree to sum sum += BITree[index]; // Move index to parent node in getSum View index -= index & (-index); } return sum; } // Updates a node in Binary Index Tree (BITree) at given // index in BITree. The given value 'val' is added to // BITree[i] and all of its ancestors in tree. function updateBIT(BITreenindexval) { // index in BITree[] is 1 more than the index in arr[] index = index + 1; // Traverse all ancestors and add 'val' while (index <= n) { // Add 'val' to current node of BI Tree BITree[index] += val; // Update index to that of parent in update View index += index & (-index); } } // Returns the sum of array from [0 x] function sum(xBITTree1BITTree2) { return (getSum(BITTree1 x) * x) - getSum(BITTree2 x); } function updateRange(BITTree1BITTree2nvallr) { // Update Both the Binary Index Trees // As discussed in the article // Update BIT1 updateBIT(BITTree1 n l val); updateBIT(BITTree1 n r + 1 -val); // Update BIT2 updateBIT(BITTree2 n l val * (l - 1)); updateBIT(BITTree2 n r + 1 -val * r); } function rangeSum(lrBITTree1BITTree2) { // Find sum from [0r] then subtract sum // from [0l-1] in order to find sum from // [lr] return sum(r BITTree1 BITTree2) - sum(l - 1 BITTree1 BITTree2); } function constructBITree(n) { // Create and initialize BITree[] as 0 let BITree = new Array(n + 1); for (let i = 1; i <= n; i++) BITree[i] = 0; return BITree; } // Driver Program to test above function let n = 5; // Contwo BIT let BITTree1; let BITTree2; // BIT1 to get element at any index // in the array BITTree1 = constructBITree(n); // BIT 2 maintains the extra term // which needs to be subtracted BITTree2 = constructBITree(n); // Add 5 to all the elements from [04] let l = 0 r = 4 val = 5; updateRange(BITTree1 BITTree2 n val l r); // Add 10 to all the elements from [24] l = 2 ; r = 4 ; val = 10; updateRange(BITTree1 BITTree2 n val l r); // Find sum of all the elements from // [14] l = 1 ; r = 4; document.write('Sum of elements from [' + l + '' + r+ '] is '); document.write(rangeSum(l r BITTree1 BITTree2)+ '
'); // This code is contributed by rag2127 </script>
Produzione
Sum of elements from [14] is 50
Complessità temporale : O(q * log(N)) dove q è il numero di query.
Spazio ausiliario: SU)