Q13:Assume you have an array of length n initialized with all 0's and are given k update operations.
Each operation is represented as a triplet: [startIndex, endIndex, inc] which increments each element of subarray A[startIndex ... endIndex] (startIndex and endIndex inclusive) with inc.
Return the modified array after all k operations were executed.
Example
Given:
length = 5,
updates =
[
[1, 3, 2],
[2, 4, 3],
[0, 2, -2]
]
return [-2, 0, 3, 5, 3]
Explanation:
Initial state:
[ 0, 0, 0, 0, 0 ]
After applying operation [1, 3, 2]:
[ 0, 2, 2, 2, 0 ]
After applying operation [2, 4, 3]:
[ 0, 2, 5, 5, 3 ]
After applying operation [0, 2, -2]:
[-2, 0, 3, 5, 3 ]
Solution:
class Solution {
public:
vector<int> getModifiedArray(int length, vector<vector<int>> &updates) {
vector<int>ans(n,0);
vector<int>psum(n+1,0);
for(int i=0;i<updates.size();i++){
psum[updates[i][0]]+=updates[i][2];
psum[updates[i][1]+1] -=updates[i][2];
}
int sum=0;
for(int i=0;i<n;i++){
sum +=psum[i];
ans[i]=sum;
}
return ans;
}
};
Explantion:
>Initialize Arrays:
Create two arrays, ans and psum, both of size 'length' (given as 'n' in the code).
ans will store the final modified array, and psum will be used to track increments.
>Process Updates:
Iterate through the given vector of updates.
For each update [startIndex, endIndex, inc]:
Add 'inc' to the element at psum[startIndex].
Subtract 'inc' from the element at psum[endIndex + 1].
This step efficiently represents the increments in the array.
>Calculate Cumulative Sum:
Initialize a variable sum to 0.
Iterate through the array and update sum with the cumulative sum of increments from psum.
Set the corresponding element in the ans array to the calculated sum.
This step computes the final modified array.
>Return Result:
The ans array now contains the modified array after all updates.
Return the ans array as the result.
If anyone have better solution so please comment:)