Sum of previous numbers that are greater than current number for given array

11 Mar, 2022
Given an array A[], for each element in the array, the task is to find the sum of all the previous elements which are strictly greater than the current element.
Examples:
Input: A[] = {2, 6, 4, 1, 7}Output: 0 0 6 12 0Explanation: For 2 and 6 there is no element greater to it on the left.For 4 there is 6.For 1 the sum would be 12.For 7 there is again no element greater to it.
Input: A[] = {7, 3, 6, 2, 1}Output: 0 7 7 16 18Explanation: For 7 there is no element greater to it on the left. For 3 there is 7.For 6 the sum would be 7.For 2 it has to be 7 + 3 + 6 = 16.For 1 the sum would be 7 + 3 + 6 + 2 = 18
Naive Approach: For each element, the idea is to find the elements which are strictly greater than the current element on the left side of it and then find the sum of all those elements.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Max Element of the Arrayconst int maxn = 1000000; // Function to find the sum of previous// numbers that are greater than the// current number for the given arrayvoid sumGreater(int ar[], int N){     // Loop to iterate over all    // the elements of the array    for (int i = 0; i < N; i++) {         // Store the answer for        // the current element        int cur_sum = 0;         // Iterate from (current index - 1)        // to 0 and check if ar[j] is greater        // than the current element and add        // it to the cur_sum if so         for (int j = i - 1; j >= 0; j--) {             if (ar[j] > ar[i])                cur_sum += ar[j];        }         // Print the answer for        // current element        cout << cur_sum << " ";    }} // Driver Codeint main(){    // Given array arr[]    int ar[] = { 7, 3, 6, 2, 1 };     // Size of the array    int N = sizeof ar / sizeof ar[0];     // Function call    sumGreater(ar, N);    return 0;}
// Java program for the above approachclass GFG{ // Max Element of the Arraystatic int maxn = 1000000; // Function to find the sum of previous// numbers that are greater than the// current number for the given arraystatic void sumGreater(int ar[], int N){         // Loop to iterate over all    // the elements of the array    for(int i = 0; i < N; i++)    {                 // Store the answer for        // the current element        int cur_sum = 0;         // Iterate from (current index - 1)        // to 0 and check if ar[j] is greater        // than the current element and add        // it to the cur_sum if so        for(int j = i - 1; j >= 0; j--)        {            if (ar[j] > ar[i])                cur_sum += ar[j];        }         // Print the answer for        // current element        System.out.print(cur_sum + " ");    }} // Driver Codepublic static void main(String[] args){         // Given array arr[]    int ar[] = { 7, 3, 6, 2, 1 };     // Size of the array    int N = ar.length;     // Function call    sumGreater(ar, N);}} // This code is contributed by amal kumar choubey
# Python3 program for the above approach # Max Element of the Arraymaxn = 1000000; # Function to find the sum of previous# numbers that are greater than the# current number for the given arraydef sumGreater(ar, N):     # Loop to iterate over all    # the elements of the array    for i in range(N):         # Store the answer for        # the current element        cur_sum = 0;         # Iterate from (current index - 1)        # to 0 and check if ar[j] is greater        # than the current element and add        # it to the cur_sum if so        for j in range(i, -1, -1):            if (ar[j] > ar[i]):                cur_sum += ar[j];                 # Print the answer for        # current element        print(cur_sum, end = " ");     # Driver Codeif __name__ == '__main__':     # Given array arr    ar = [ 7, 3, 6, 2, 1] ;     # Size of the array    N = len(ar);     # Function call    sumGreater(ar, N); # This code is contributed by sapnasingh4991
// C# program for the above approachusing System; class GFG{ // Max Element of the Array//static int maxn = 1000000; // Function to find the sum of previous// numbers that are greater than the// current number for the given arraystatic void sumGreater(int []ar, int N){         // Loop to iterate over all    // the elements of the array    for(int i = 0; i < N; i++)    {                 // Store the answer for        // the current element        int cur_sum = 0;         // Iterate from (current index - 1)        // to 0 and check if ar[j] is greater        // than the current element and add        // it to the cur_sum if so        for(int j = i - 1; j >= 0; j--)        {            if (ar[j] > ar[i])                cur_sum += ar[j];        }         // Print the answer for        // current element        Console.Write(cur_sum + " ");    }} // Driver Codepublic static void Main(String[] args){         // Given array []arr    int []ar = { 7, 3, 6, 2, 1 };     // Size of the array    int N = ar.Length;     // Function call    sumGreater(ar, N);}} // This code is contributed by Amit Katiyar
<script> // Javascript program for the above approach   // Max Element of the Arrayvar maxn = 1000000; // Function to find the sum of previous// numbers that are greater than the// current number for the given arrayfunction sumGreater(ar, N){         // Loop to iterate over all    // the elements of the array    for(i = 0; i < N; i++)    {                 // Store the answer for        // the current element        var cur_sum = 0;         // Iterate from (current index - 1)        // to 0 and check if ar[j] is greater        // than the current element and add        // it to the cur_sum if so        for(j = i - 1; j >= 0; j--)        {            if (ar[j] > ar[i])                cur_sum += ar[j];        }         // Print the answer for        // current element        document.write(cur_sum + " ");    }} // Driver Code // Given array arrvar ar = [ 7, 3, 6, 2, 1 ]; // Size of the arrayvar N = ar.length; // Function callsumGreater(ar, N); // This code is contributed by umadevi9616 </script>
0 7 7 16 18
 
Time Complexity: O(N2)Auxiliary Space: O(1)
Efficient Approach: To optimize the above approach the idea is to use Fenwick Tree. Below are the steps:
Traverse the given array and find the sum(say total_sum) of all the elements stored in the Fenwick Tree.Now Consider each element(say arr[i]) as the index of the Fenwick Tree.Now find the sum of all the elements(say curr_sum) which is smaller than the current element using values stored in Tree.The value of total_sum – curr_sum will give the sum of all elements which are strictly greater than the elements on the left side of the current element.Update the current element in the Fenwick Tree.Repeat the above steps for all the elements in the array.
Traverse the given array and find the sum(say total_sum) of all the elements stored in the Fenwick Tree.
Now Consider each element(say arr[i]) as the index of the Fenwick Tree.
Now find the sum of all the elements(say curr_sum) which is smaller than the current element using values stored in Tree.
The value of total_sum – curr_sum will give the sum of all elements which are strictly greater than the elements on the left side of the current element.
Update the current element in the Fenwick Tree.
Repeat the above steps for all the elements in the array.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; // Max Element of the Arrayconst int maxn = 1000000; // Initializing Fenwick Treeint Bit[maxn + 5]; // Function to calculate the sum of// previous numbers that are greater// than the current number in the arrayvoid sum(int ar[], int N){     // Iterate from 1 to N    for (int i = 0; i < N; i++) {        int index;        int total_sum = 0;        index = 100000;         // If some greater values has        // occurred before current element        // then it will be already stored        // in Fenwick Tree        while (index) {             // Calculating sum of            // all the elements            total_sum += Bit[index];            index -= index & -index;        }        int cur_sum = 0;         // Sum only smaller or equal        // elements than current element        index = ar[i];         while (index) {             // If some smaller values has            // occurred before it will be            // already stored in Tree            cur_sum += Bit[index];            index -= (index & -index);        }         int ans = total_sum - cur_sum;        cout << ans << " ";         // Update the fenwick tree        index = ar[i];        while (index <= 100000) {             // Updating The Fenwick Tree            // for future values            Bit[index] += ar[i];            index += (index & -index);        }    }} // Driver Codeint main(){    // Given array arr[]    int ar[] = { 7, 3, 6, 2, 1 };    int N = sizeof ar / sizeof ar[0];     // Function call    sum(ar, N);    return 0;}
// Java program for the above approachimport java.util.*;class GFG{ // Max Element of the Arraystatic int maxn = 1000000; // Initializing Fenwick Treestatic int []Bit = new int[maxn + 5]; // Function to calculate the sum of// previous numbers that are greater// than the current number in the arraystatic void sum(int ar[], int N){     // Iterate from 1 to N    for (int i = 0; i < N; i++)    {        int index;        int total_sum = 0;        index = 100000;         // If some greater values has        // occurred before current element        // then it will be already stored        // in Fenwick Tree        while (index > 0)        {             // Calculating sum of            // all the elements            total_sum += Bit[index];            index -= index & -index;        }        int cur_sum = 0;         // Sum only smaller or equal        // elements than current element        index = ar[i];         while (index > 0)        {             // If some smaller values has            // occurred before it will be            // already stored in Tree            cur_sum += Bit[index];            index -= (index & -index);        }         int ans = total_sum - cur_sum;        System.out.print(ans + " ");         // Update the fenwick tree        index = ar[i];        while (index <= 100000)        {             // Updating The Fenwick Tree            // for future values            Bit[index] += ar[i];            index += (index & -index);        }    }} // Driver Codepublic static void main(String[] args){    // Given array arr[]    int ar[] = { 7, 3, 6, 2, 1 };    int N = ar.length;     // Function call    sum(ar, N);}} // This code is contributed by Rohit_ranjan
# Python3 program for the above approach # Max Element of the Arraymaxn = 1000000; # Initializing Fenwick TreeBit = [0] * (maxn + 5); # Function to calculate the sum of# previous numbers that are greater# than the current number in the arraydef sum(ar, N):       # Iterate from 1 to N    for i in range(N):        total_sum = 0;        index = 100000;         # If some greater values has        # occurred before current element        # then it will be already stored        # in Fenwick Tree        while (index > 0):                       # Calculating sum of            # all the elements            total_sum += Bit[index];            index -= index & -index;         cur_sum = 0;         # Sum only smaller or equal        # elements than current element        index = ar[i];         while (index > 0):                       # If some smaller values has            # occurred before it will be            # already stored in Tree            cur_sum += Bit[index];            index -= (index & -index);         ans = total_sum - cur_sum;        print(ans, end=" ");         # Update the fenwick tree        index = ar[i];        while (index <= 100000):                       # Updating The Fenwick Tree            # for future values            Bit[index] += ar[i];            index += (index & -index); # Driver Codeif __name__ == '__main__':    # Given array arr    arr = [7, 3, 6, 2, 1];    N = len(arr);     # Function call    sum(arr, N); # This code is contributed by sapnasingh4991
// C# program for the above approachusing System;class GFG{ // Max Element of the Arraystatic int maxn = 1000000; // Initializing Fenwick Treestatic int []Bit = new int[maxn + 5]; // Function to calculate the sum of// previous numbers that are greater// than the current number in the arraystatic void sum(int []ar, int N){     // Iterate from 1 to N    for (int i = 0; i < N; i++)    {        int index;        int total_sum = 0;        index = 100000;         // If some greater values has        // occurred before current element        // then it will be already stored        // in Fenwick Tree        while (index > 0)        {             // Calculating sum of            // all the elements            total_sum += Bit[index];            index -= index & -index;        }        int cur_sum = 0;         // Sum only smaller or equal        // elements than current element        index = ar[i];         while (index > 0)        {             // If some smaller values has            // occurred before it will be            // already stored in Tree            cur_sum += Bit[index];            index -= (index & -index);        }         int ans = total_sum - cur_sum;        Console.Write(ans + " ");         // Update the fenwick tree        index = ar[i];        while (index <= 100000)        {             // Updating The Fenwick Tree            // for future values            Bit[index] += ar[i];            index += (index & -index);        }    }} // Driver Codepublic static void Main(String[] args){    // Given array []arr    int []ar = { 7, 3, 6, 2, 1 };    int N = ar.Length;     // Function call    sum(ar, N);}} // This code is contributed by Rajput-Ji
<script>// javascript program for the above approach     // Max Element of the Array    var maxn = 1000000;     // Initializing Fenwick Tree     var Bit = Array(maxn + 5).fill(0);     // Function to calculate the sum of    // previous numbers that are greater    // than the current number in the array    function sum(ar , N) {         // Iterate from 1 to N        for (i = 0; i < N; i++) {            var index;            var total_sum = 0;            index = 100000;             // If some greater values has            // occurred before current element            // then it will be already stored            // in Fenwick Tree            while (index > 0) {                 // Calculating sum of                // all the elements                total_sum += Bit[index];                index -= index & -index;            }            var cur_sum = 0;             // Sum only smaller or equal            // elements than current element            index = ar[i];             while (index > 0) {                 // If some smaller values has                // occurred before it will be                // already stored in Tree                cur_sum += Bit[index];                index -= (index & -index);            }             var ans = total_sum - cur_sum;            document.write(ans + " ");             // Update the fenwick tree            index = ar[i];            while (index <= 100000) {                 // Updating The Fenwick Tree                // for future values                Bit[index] += ar[i];                index += (index & -index);            }        }    }     // Driver Code             // Given array arr        var ar = [ 7, 3, 6, 2, 1 ];        var N = ar.length;         // Function call        sum(ar, N); // This code contributed by aashish1995</script>
0 7 7 16 18
 
Time Complexity: O(N * log(max_element))Auxiliary Space: O(max_element)
 
Amal Kumar Choubey
amit143katiyar
Rohit_ranjan
Rajput-Ji
sapnasingh4991
umadevi9616
aashish1995
adnanirshad158
nikhatkhan11
sumitgumber28
Binary Indexed Tree
BIT
Segment-Tree
Arrays
Competitive Programming
Tree
Arrays
Tree
Binary Indexed Tree
Segment-Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Stack Data Structure (Introduction and Program)
Linear Search
Competitive Programming - A Complete Guide
Practice for cracking any coding interview
Arrow operator -> in C/C++ with Examples
Modulo 10^9+7 (1000000007)
Prefix Sum Array - Implementation and Applications in Competitive Programming