查询以给定的次数将给定范围内的数组元素递增给定值

给定一个由N个正整数组成的数组arr []和M个形式为{a，b，val，f}的查询。任务是在执行每个查询以将范围[a，b]中的数组元素递增val f次后打印数组。

例子：

Input: arr[] = {1, 2, 3}, M=3, Q[][] = { {1, 2, 1, 4}, {1, 3, 2, 3}, {2, 3, 4, 5}}
Output: 11 32 29
Explanation: 
After applying 1st Query 4 times, 
Array will be: 5 6 3
After applying 2nd Query 3 times, 
Array will be: 11 12 9
After applying 3rd Query 5 times, 
Array will be: 11 32 29
Therefore, the final array will br {11, 32, 29}.

Input: arr[] = {1},  M = 1, Q[][] = {{1, 1, 1, 1}}
Output: 2
Explanation: 
After applying 1st and the only query 1 time only.
Array will be: 2

天真的方法：最简单的方法是对给定数组执行每个查询，即对于每个查询{a，b，val，f}在[a，b]范围内遍历数组，并将值val的每个元素增加到f数的时间。执行每个查询后，打印阵列。

时间复杂度： O(N * M * max(Freq))
辅助空间： O(1)

更好的方法：该想法基于可以在范围更新操作中使用的差异数组。步骤如下：

1. 找出给定数组A []的差数组D []定义为D [i] =(A [i] – A [i – 1]) (0 D [0] = A [ [0]考虑基于0的索引。
2. 将val加到D [a – 1]并从D [(b – 1)+1 ]中减去，即D [a – 1] + = val，D [(b – 1)+ 1]-= val。执行的时候，这操作频率号码。
3. 现在，使用差分数组更新给定的数组。将A [0]更新为D [0]并打印。对于其余元素，执行A [i] = A [i-1] + D [i] 。
4. 完成上述步骤后，打印结果数组。

时间复杂度： O(N + M * max(Freq))
辅助空间： O(N)差分数组的额外空间

高效方法：该方法与以前的方法相似，但是是差异数组应用程序的扩展版本。以前的任务是通过val ， f次将索引a到b的值更新。在这里，而不是调用范围更新函数f的次数，把它只有一次每个查询：

1. 通过val * f将索引a的值更新为b ，每个查询仅更新1次。
2. 将val * f添加到D [a – 1]并将其从D [(b – 1)+1 ]中减去，即，将D [a – 1]增加val * f ，然后将D [b]减少val * f 。
3. 现在，使用差分数组更新主数组。将A [0]更新为D [0]并打印。
4. 对于其余元素，将A [i]更新为(A [i-1] + D [i]) 。
5. 完成上述步骤后，打印结果数组。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function that creates a difference
// array D[] for A[]
vector initializeDiffArray(
    vector& A)
{
    int N = A.size();
 
    // Stores the difference array
    vector D(N + 1);
 
    D[0] = A[0], D[N] = 0;
 
    // Update difference array D[]
    for (int i = 1; i < N; i++)
        D[i] = A[i] - A[i - 1];
 
    // Return difference array
    return D;
}
 
// Function that performs the range
// update queries
void update(vector& D, int l,
            int r, int x)
{
    // Update the ends of the range
    D[l] += x;
    D[r + 1] -= x;
}
 
// Function that perform all query
// once with modified update Call
void UpdateDiffArray(vector& DiffArray,
                     int Start, int End,
                     int Val, int Freq)
{
    // For range update, difference
    // array is modified
    update(DiffArray, Start - 1,
           End - 1, Val * Freq);
}
 
// Function to take queries
void queriesInput(vector& DiffArray,
                  int Q[][4], int M)
{
    // Traverse the query
    for (int i = 0; i < M; i++) {
 
        // Function Call for updates
        UpdateDiffArray(DiffArray, Q[i][0],
                        Q[i][1], Q[i][2],
                        Q[i][3]);
    }
}
 
// Function to updates the array
// using the difference array
void UpdateArray(vector& A,
                 vector& D)
{
    // Traverse the array A[]
    for (int i = 0; i < A.size(); i++) {
 
        // 1st Element
        if (i == 0) {
            A[i] = D[i];
        }
 
        // A[0] or D[0] decides values
        // of rest of the elements
        else {
            A[i] = D[i] + A[i - 1];
        }
    }
}
 
// Function that prints the array
void PrintArray(vector& A)
{
    // Print the element
    for (int i = 0; i < A.size(); i++) {
        cout << A[i] << " ";
    }
 
    return;
}
 
// Function that print the array
// after performing all queries
void printAfterUpdate(vector& A,
                      int Q[][4], int M)
{
    // Create and fill difference
    // array for range updates
    vector DiffArray
        = initializeDiffArray(A);
 
    queriesInput(DiffArray, Q, M);
 
    // Now update Array A using
    // Difference Array
    UpdateArray(A, DiffArray);
 
    // Print updated Array A
    // after M queries
    PrintArray(A);
}
 
// Driver Code
int main()
{
    // N = Array size, M = Queries
    int N = 3, M = 3;
 
    // Given array A[]
    vector A{ 1, 2, 3 };
 
    // Queries
    int Q[][4] = { { 1, 2, 1, 4 },
                   { 1, 3, 2, 3 },
                   { 2, 3, 4, 5 } };
 
    // Function Call
    printAfterUpdate(A, Q, M);
 
    return 0;
}

Java

// Java program for the
// above approach
import java.util.*;
class GFG{
   
// N = Array size,
// M = Queries
static int N = 3, M = 3;
   
static int []A = new int[N];
 
//Stores the difference array
static int []D = new int[N + 1];
   
// Function that creates
// a difference array D[]
// for A[]
static void initializeDiffArray()
{
  D[0] = A[0];
  D[N] = 0;
 
  // Update difference array D[]
  for (int i = 1; i < N; i++)
    D[i] = A[i] - A[i - 1];
}
 
// Function that performs
// the range update queries
static void update(int l,
                   int r, int x)
{
  // Update the ends
  // of the range
  D[l] += x;
  D[r + 1] -= x;
}
 
// Function that perform all query
// once with modified update Call
static void UpdateDiffArray(int Start, int End,
                            int Val, int Freq)
{
  // For range update, difference
  // array is modified
  update(Start - 1,
         End - 1, Val * Freq);
}
 
// Function to take queries
static void queriesInput(  int Q[][])
{
  // Traverse the query
  for (int i = 0; i < M; i++)
  {
    // Function Call for updates
    UpdateDiffArray(Q[i][0], Q[i][1],
                    Q[i][2], Q[i][3]);
  }
}
 
// Function to updates the array
// using the difference array
static void UpdateArray()
{
  // Traverse the array A[]
  for (int i = 0; i < N; i++)
  {
    // 1st Element
    if (i == 0)
    {
      A[i] = D[i];
    }
 
    // A[0] or D[0] decides
    // values of rest of
    // the elements
    else
    {
      A[i] = D[i] + A[i - 1];
    }
  }
}
 
// Function that prints
// the array
static void PrintArray()
{
  // Print the element
  for (int i = 0; i < N; i++)
  {
    System.out.print(A[i] + i +
                     1 + " ");
  }
  return;
}
 
// Function that print the array
// after performing all queries
static void printAfterUpdate(int []A,
                             int Q[][], int M)
{
  // Create and fill difference
  // array for range updates
  initializeDiffArray();
 
  queriesInput( Q);
 
  // Now update Array
  // A using Difference
  // Array
  UpdateArray();
 
  // Print updated Array A
  // after M queries
  PrintArray();
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array A[]
  int []A = {1, 2, 3};
 
  // Queries
  int [][]Q = {{1, 2, 1, 4},
               {1, 3, 2, 3},
               {2, 3, 4, 5}};
 
  // Function Call
  printAfterUpdate(A, Q, M);
}
}
 
// This code is contributed by gauravrajput1

Python3

# Python3 program for the above approach
 
# Function that creates a difference
# array D[] for A[]
def initializeDiffArray(A):
     
    N = len(A)
 
    # Stores the difference array
    D = [0] * (N + 1)
 
    D[0] = A[0]
    D[N] = 0
 
    # Update difference array D[]
    for i in range(1, N):
        D[i] = A[i] - A[i - 1]
 
    # Return difference array
    return D
 
# Function that performs the range
# update queries
def update(D, l, r, x):
     
    # Update the ends of the range
    D[l] += x
    D[r + 1] -= x
 
# Function that perform all query
# once with modified update Call
def UpdateDiffArray(DiffArray, Start,
                    End, Val, Freq):
                         
    # For range update, difference
    # array is modified
    update(DiffArray, Start - 1,
           End - 1, Val * Freq)
 
# Function to take queries
def queriesInput(DiffArray, Q, M):
     
    # Traverse the query
    for i in range(M):
 
        # Function Call for updates
        UpdateDiffArray(DiffArray, Q[i][0],
                          Q[i][1], Q[i][2],
                          Q[i][3])
 
# Function to updates the array
# using the difference array
def UpdateArray(A, D):
     
    # Traverse the array A[]
    for i in range(len(A)):
 
        # 1st Element
        if (i == 0):
            A[i] = D[i]
 
        # A[0] or D[0] decides values
        # of rest of the elements
        else:
            A[i] = D[i] + A[i - 1]
 
# Function that prints the array
def PrintArray(A):
     
    # Print the element
    for i in range(len(A)):
        print(A[i], end = " ")
         
    return
 
# Function that prthe array
# after performing all queries
def printAfterUpdate(A, Q, M):
     
    # Create and fill difference
    # array for range updates
    DiffArray = initializeDiffArray(A)
 
    queriesInput(DiffArray, Q, M)
 
    # Now update Array A using
    # Difference Array
    UpdateArray(A, DiffArray)
 
    # Prupdated Array A
    # after M queries
    PrintArray(A)
 
# Driver Code
if __name__ == '__main__':
     
    # N = Array size, M = Queries
    N = 3
    M = 3
 
    # Given array A[]
    A = [ 1, 2, 3 ]
 
    # Queries
    Q = [ [ 1, 2, 1, 4 ],
          [ 1, 3, 2, 3 ],
          [ 2, 3, 4, 5 ] ]
 
    # Function call
    printAfterUpdate(A, Q, M)
 
# This code is contributed by mohit kumar 29

C#

// C# program for the
// above approach
using System;
class GFG{
 
// N = Array size,
// M = Queries
static int N = 3, M = 3;
 
static int[] A = new int[N];
 
// Stores the difference array
static int[] D = new int[N + 1];
 
// Function that creates
// a difference array D[]
// for A[]
static void initializeDiffArray()
{
  D[0] = A[0];
  D[N] = 0;
 
  // Update difference array D[]
  for (int i = 1; i < N; i++)
    D[i] = A[i] - A[i - 1];
}
 
// Function that performs
// the range update queries
static void update(int l,
                   int r, int x)
{
  // Update the ends
  // of the range
  D[l] += x;
  D[r + 1] -= x;
}
 
// Function that perform all query
// once with modified update Call
static void UpdateDiffArray(int Start, int End,
                            int Val, int Freq)
{
  // For range update, difference
  // array is modified
  update(Start - 1,
         End - 1, Val * Freq);
}
 
// Function to take queries
static void queriesInput(int[, ] Q)
{
  // Traverse the query
  for (int i = 0; i < M; i++)
  {
    // Function Call for updates
    UpdateDiffArray(Q[i, 0], Q[i, 1],
                    Q[i, 2], Q[i, 3]);
  }
}
 
// Function to updates the array
// using the difference array
static void UpdateArray()
{
  // Traverse the array A[]
  for (int i = 0; i < N; i++)
  {
    // 1st Element
    if (i == 0)
    {
      A[i] = D[i];
    }
 
    // A[0] or D[0] decides
    // values of rest of
    // the elements
    else
    {
      A[i] = D[i] + A[i - 1];
    }
  }
}
 
// Function that prints
// the array
static void PrintArray()
{
  // Print the element
  for (int i = 0; i < N; i++)
  {
    Console.Write(A[i] + i +
                  1 + " ");
  }
  return;
}
 
// Function that print the array
// after performing all queries
static void printAfterUpdate(int[] A,
                             int[, ] Q, int M)
{
  // Create and fill difference
  // array for range updates
  initializeDiffArray();
 
  queriesInput(Q);
 
  // Now update Array
  // A using Difference
  // Array
  UpdateArray();
 
  // Print updated Array A
  // after M queries
  PrintArray();
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array A[]
  int[] A = {1, 2, 3};
 
  // Queries
  int[, ] Q = {{1, 2, 1, 4},
               {1, 3, 2, 3},
               {2, 3, 4, 5}};
 
  // Function Call
  printAfterUpdate(A, Q, M);
}
 
// This code is contributed by Chitranayal

输出

11 32 29 

时间复杂度： O(N + M)
辅助空间： O(N)