Considere una array A[] de enteros y los siguientes dos tipos de consultas.
- update(l, r, x) : Agrega x a todos los valores de A[l] a A[r] (ambos inclusive).
- printArray() : Imprime la array modificada actual.
Ejemplos:
Input : A [] { 10, 5, 20, 40 }
update(0, 1, 10)
printArray()
update(1, 3, 20)
update(2, 2, 30)
printArray()
Output : 20 15 20 40
20 35 70 60
Explanation : The query update(0, 1, 10)
adds 10 to A[0] and A[1]. After update,
A[] becomes {20, 15, 20, 40}
Query update(1, 3, 20) adds 20 to A[1],
A[2] and A[3]. After update, A[] becomes
{20, 35, 40, 60}.
Query update(2, 2, 30) adds 30 to A[2].
After update, A[] becomes {20, 35, 70, 60}.
Una solución simple es hacer lo siguiente:
- update(l, r, x) : ejecuta un ciclo de l a r y agrega x a todos los elementos de A[l] a A[r]
- printArray() : Simplemente imprime A[].
La complejidad del tiempo de las dos operaciones anteriores es O(n).
Una solución eficiente es usar una array de diferencias.
El arreglo de diferencias D[i] de un arreglo dado A[i] se define como D[i] = A[i]-A[i-1] (para 0 < i < N ) y D[0] = A[0 ] considerando la indexación basada en 0. La array de diferencias se puede usar para realizar consultas de actualización de rango «lrx», donde l es el índice izquierdo, r es el índice derecho y x es el valor que se agregará y, después de todas las consultas, puede devolver la array original. Donde las operaciones de rango de actualización se pueden realizar en complejidad O (1).
- update(l, r, x) : sumamos x a D[l] y lo restamos de D[r+1], es decir, hacemos D[l] += x, D[r+1] -= x
- printArray() : Haz A[0] = D[0] e imprímelo. Para el resto de los elementos, haz A[i] = A[i-1] + D[i] e imprímelos.
La complejidad del tiempo de actualización aquí se mejora a O(1) . Tenga en cuenta que printArray() aún toma tiempo O(n).
C++
// C++ code to demonstrate Difference Array
#include <bits/stdc++.h>
using namespace std;
// Creates a diff array D[] for A[] and returns
// it after filling initial values.
vector<int> initializeDiffArray(vector<int>& A)
{
int n = A.size();
// We use one extra space because
// update(l, r, x) updates D[r+1]
vector<int> D(n + 1);
D[0] = A[0], D[n] = 0;
for (int i = 1; i < n; i++)
D[i] = A[i] - A[i - 1];
return D;
}
// Does range update
void update(vector<int>& D, int l, int r, int x)
{
D[l] += x;
D[r + 1] -= x;
}
// Prints updated Array
int printArray(vector<int>& A, vector<int>& D)
{
for (int i = 0; i < A.size(); i++) {
if (i == 0)
A[i] = D[i];
// Note that A[0] or D[0] decides
// values of rest of the elements.
else
A[i] = D[i] + A[i - 1];
cout << A[i] << " ";
}
cout << endl;
}
// Driver Code
int main()
{
// Array to be updated
vector<int> A{ 10, 5, 20, 40 };
// Create and fill difference Array
vector<int> D = initializeDiffArray(A);
// After below update(l, r, x), the
// elements should become 20, 15, 20, 40
update(D, 0, 1, 10);
printArray(A, D);
// After below updates, the
// array should become 30, 35, 70, 60
update(D, 1, 3, 20);
update(D, 2, 2, 30);
printArray(A, D);
return 0;
}
Java
// Java code to demonstrate Difference Array
class GFG {
// Creates a diff array D[] for A[] and returns
// it after filling initial values.
static void initializeDiffArray(int A[], int D[])
{
int n = A.length;
D[0] = A[0];
D[n] = 0;
for (int i = 1; i < n; i++)
D[i] = A[i] - A[i - 1];
}
// Does range update
static void update(int D[], int l, int r, int x)
{
D[l] += x;
D[r + 1] -= x;
}
// Prints updated Array
static int printArray(int A[], int D[])
{
for (int i = 0; i < A.length; i++) {
if (i == 0)
A[i] = D[i];
// Note that A[0] or D[0] decides
// values of rest of the elements.
else
A[i] = D[i] + A[i - 1];
System.out.print(A[i] + " ");
}
System.out.println();
return 0;
}
// Driver Code
public static void main(String[] args)
{
// Array to be updated
int A[] = { 10, 5, 20, 40 };
int n = A.length;
// Create and fill difference Array
// We use one extra space because
// update(l, r, x) updates D[r+1]
int D[] = new int[n + 1];
initializeDiffArray(A, D);
// After below update(l, r, x), the
// elements should become 20, 15, 20, 40
update(D, 0, 1, 10);
printArray(A, D);
// After below updates, the
// array should become 30, 35, 70, 60
update(D, 1, 3, 20);
update(D, 2, 2, 30);
printArray(A, D);
}
}
// This code is contributed by Anant Agarwal.
Python3
# Python3 code to demonstrate Difference Array
# Creates a diff array D[] for A[] and returns
# it after filling initial values.
def initializeDiffArray( A):
n = len(A)
# We use one extra space because
# update(l, r, x) updates D[r+1]
D = [0 for i in range(0 , n + 1)]
D[0] = A[0]; D[n] = 0
for i in range(1, n ):
D[i] = A[i] - A[i - 1]
return D
# Does range update
def update(D, l, r, x):
D[l] += x
D[r + 1] -= x
# Prints updated Array
def printArray(A, D):
for i in range(0 , len(A)):
if (i == 0):
A[i] = D[i]
# Note that A[0] or D[0] decides
# values of rest of the elements.
else:
A[i] = D[i] + A[i - 1]
print(A[i], end = " ")
print ("")
# Driver Code
A = [ 10, 5, 20, 40 ]
# Create and fill difference Array
D = initializeDiffArray(A)
# After below update(l, r, x), the
# elements should become 20, 15, 20, 40
update(D, 0, 1, 10)
printArray(A, D)
# After below updates, the
# array should become 30, 35, 70, 60
update(D, 1, 3, 20)
update(D, 2, 2, 30)
printArray(A, D)
# This code is contributed by Gitanjali.
C#
// C# code to demonstrate Difference Array
using System;
class GFG {
// Creates a diff array D[] for A[] and returns
// it after filling initial values.
static void initializeDiffArray(int []A, int []D)
{
int n = A.Length;
D[0] = A[0];
D[n] = 0;
for (int i = 1; i < n; i++)
D[i] = A[i] - A[i - 1];
}
// Does range update
static void update(int []D, int l, int r, int x)
{
D[l] += x;
D[r + 1] -= x;
}
// Prints updated Array
static int printArray(int []A, int []D)
{
for (int i = 0; i < A.Length; i++) {
if (i == 0)
A[i] = D[i];
// Note that A[0] or D[0] decides
// values of rest of the elements.
else
A[i] = D[i] + A[i - 1];
Console.Write(A[i] + " ");
}
Console.WriteLine();
return 0;
}
// Driver Code
public static void Main()
{
// Array to be updated
int []A = { 10, 5, 20, 40 };
int n = A.Length;
// Create and fill difference Array
// We use one extra space because
// update(l, r, x) updates D[r+1]
int []D = new int[n + 1];
initializeDiffArray(A, D);
// After below update(l, r, x), the
// elements should become 20, 15, 20, 40
update(D, 0, 1, 10);
printArray(A, D);
// After below updates, the
// array should become 30, 35, 70, 60
update(D, 1, 3, 20);
update(D, 2, 2, 30);
printArray(A, D);
}
}
// This code is contributed by vt_m.
Javascript
<script>
// JavaScript code to demonstrate Difference Array
// Creates a diff array D[] for A[] and returns
// it after filling initial values.
function initializeDiffArray( A){
let n = A.length;
// We use one extra space because
// update(l, r, x) updates D[r+1]
let D= [];
D[0] = A[0], D[n] = 0;
for (let i = 1; i < n; i++)
D[i] = A[i] - A[i - 1];
return D;
}
// Does range update
function update(D, l, r, x){
D[l] += x;
D[r + 1] -= x;
return D;
}
// Prints updated Array
function printArray( A, D){
for (let i = 0; i < A.length; i++) {
if (i == 0)
A[i] = D[i];
// Note that A[0] or D[0] decides
// values of rest of the elements.
else
A[i] = D[i] + A[i - 1];
document.write( A[i]+ " ");
}
document.write("<br>");
}
// Driver Code
// Array to be updated
let A = [ 10, 5, 20, 40 ];
// Create and fill difference Array
let D = initializeDiffArray(A);
// After below update(l, r, x), the
// elements should become 20, 15, 20, 40
D = update(D, 0, 1, 10);
printArray(A, D);
// After below updates, the
// array should become 30, 35, 70, 60
D = update(D, 1, 3, 20);
D = update(D, 2, 2, 30);
printArray(A, D);
</script>
Producción:
20 15 20 40 20 35 70 60
Complejidad temporal: O(n)
Espacio Auxiliar: O(n)
Publicación traducida automáticamente
Artículo escrito por garg_ak0109 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA