Sum of all differences between Maximum and Minimum of increasing Subarrays
Given an array arr[] consisting of N integers, the task is to find the sum of the differences between maximum and minimum element of all strictly increasing subarrays from the given array. All subarrays need to be in their longest possible form, i.e. if a subarray [i, j] form a strictly increasing subarray, then it should be considered as a whole and not [i, k] and [k+1, j] for some i <= k <= j.
A subarray is said to be strictly increasing if for every ith index in the subarray, except the last index, arr[i+1] > arr[i]
Examples:
Input: arr[ ] = {7, 1, 5, 3, 6, 4}
Output: 7
Explanation:
All possible increasing subarrays are {7}, {1, 5}, {3, 6} and {4}
Therefore, sum = (7 – 7) + (5 – 1) + (6 – 3) + (4 – 4) = 7
Input: arr[ ] = {1, 2, 3, 4, 5, 2}
Output: 4
Explanation:
All possible increasing subarrays are {1, 2, 3, 4, 5} and {2}
Therefore, sum = (5 – 1) + (2 – 2) = 4
Approach:
Follow the steps below to solve the problem:
- Traverse the array and for each iteration, find the rightmost element up to which the current subarray is strictly increasing.
- Let i be the starting element of the current subarray, and j index up to which the current subarray is strictly increasing. The maximum and minimum values of this subarray will be arr[j] and arr[i] respectively. So, add (arr[j] – arr[i]) to the sum.
- Continue iterating for the next subarray from (j+1)th index.
- After complete traversal of the array, print the final value of sum.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int sum_of_differences( int arr[], int N)
{
int sum = 0;
int i, j, flag;
for (i = 0; i < N - 1; i++) {
if (arr[i] < arr[i + 1]) {
flag = 0;
for (j = i + 1; j < N - 1; j++) {
if (arr[j] >= arr[j + 1]) {
sum += (arr[j] - arr[i]);
i = j;
flag = 1;
break ;
}
}
if (flag == 0 && arr[i] < arr[N - 1]) {
sum += (arr[N - 1] - arr[i]);
break ;
}
}
}
return sum;
}
int main()
{
int arr[] = { 6, 1, 2, 5, 3, 4 };
int N = sizeof (arr) / sizeof (arr[0]);
cout << sum_of_differences(arr, N);
return 0;
}
|
Java
class GFG{
static int sum_of_differences( int arr[], int N)
{
int sum = 0 ;
int i, j, flag;
for (i = 0 ; i < N - 1 ; i++)
{
if (arr[i] < arr[i + 1 ])
{
flag = 0 ;
for (j = i + 1 ; j < N - 1 ; j++)
{
if (arr[j] >= arr[j + 1 ])
{
sum += (arr[j] - arr[i]);
i = j;
flag = 1 ;
break ;
}
}
if (flag == 0 && arr[i] < arr[N - 1 ])
{
sum += (arr[N - 1 ] - arr[i]);
break ;
}
}
}
return sum;
}
public static void main (String []args)
{
int arr[] = { 6 , 1 , 2 , 5 , 3 , 4 };
int N = arr.length;
System.out.print(sum_of_differences(arr, N));
}
}
|
Python3
def sum_of_differences(arr, N):
sum = 0
i = 0
while (i < N - 1 ):
if arr[i] < arr[i + 1 ]:
flag = 0
for j in range (i + 1 , N - 1 ):
if arr[j] > = arr[j + 1 ]:
sum + = (arr[j] - arr[i])
i = j
flag = 1
break
if flag = = 0 and arr[i] < arr[N - 1 ]:
sum + = (arr[N - 1 ] - arr[i])
break
i + = 1
return sum
arr = [ 6 , 1 , 2 , 5 , 3 , 4 ]
N = len (arr)
print (sum_of_differences(arr, N))
|
C#
using System;
class GFG{
static int sum_of_differences( int []arr, int N)
{
int sum = 0;
int i, j, flag;
for (i = 0; i < N - 1; i++)
{
if (arr[i] < arr[i + 1])
{
flag = 0;
for (j = i + 1; j < N - 1; j++)
{
if (arr[j] >= arr[j + 1])
{
sum += (arr[j] - arr[i]);
i = j;
flag = 1;
break ;
}
}
if (flag == 0 && arr[i] < arr[N - 1])
{
sum += (arr[N - 1] - arr[i]);
break ;
}
}
}
return sum;
}
public static void Main ( string []args)
{
int []arr = { 6, 1, 2, 5, 3, 4 };
int N = arr.Length;
Console.Write(sum_of_differences(arr, N));
}
}
|
Javascript
<script>
function sum_of_differences(arr, N)
{
let sum = 0;
let i, j, flag;
for (i = 0; i < N - 1; i++)
{
if (arr[i] < arr[i + 1])
{
flag = 0;
for (j = i + 1; j < N - 1; j++)
{
if (arr[j] >= arr[j + 1])
{
sum += (arr[j] - arr[i]);
i = j;
flag = 1;
break ;
}
}
if (flag == 0 && arr[i] < arr[N - 1])
{
sum += (arr[N - 1] - arr[i]);
break ;
}
}
}
return sum;
}
let arr = [ 6, 1, 2, 5, 3, 4 ];
let N = arr.length;
document.write(sum_of_differences(arr, N));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Two pointers approach:
Approach:
We can use two pointers to optimize the dynamic programming approach further. We can maintain two pointers i and j such that i points to the start of the increasing subarray and j points to the end of the increasing subarray. We can initialize both pointers to 0 and then move j to the right until we find a non-increasing element. Then we can update the difference and move i to the right until we find a non-decreasing element
- Initialize i and j to 0 and diff to 0.
- While j is less than n, do the following:
- While j is less than n-1 and the current element arr[j] is less than the next element arr[j+1], increment j.
- Calculate the difference between the maximum and minimum values in the current increasing subarray (arr[j] – arr[i]) and add it to diff.
- Set i and j to j+1.
- Return diff.
C++
#include <iostream>
#include <vector>
using namespace std;
int max_min_diff(vector< int > arr) {
int n = arr.size();
int i = 0, j = 0;
int diff = 0;
while (j < n) {
while (j < n - 1 && arr[j] < arr[j + 1]) {
j++;
}
diff += arr[j] - arr[i];
i = j = j + 1;
}
return diff;
}
int main() {
vector< int > arr1 = {7, 1, 5, 3, 6, 4};
vector< int > arr2 = {1, 2, 3, 4, 5, 2};
cout << max_min_diff(arr1) << endl;
cout << max_min_diff(arr2) << endl;
return 0;
}
|
Java
import java.util.ArrayList;
import java.util.List;
public class Main {
static int maxMinDiff(List<Integer> arr) {
int n = arr.size();
int i = 0 , j = 0 ;
int diff = 0 ;
while (j < n) {
while (j < n - 1 && arr.get(j) < arr.get(j + 1 )) {
j++;
}
diff += arr.get(j) - arr.get(i);
i = j = j + 1 ;
}
return diff;
}
public static void main(String[] args) {
List<Integer> arr1 = new ArrayList<>(List.of( 7 , 1 , 5 , 3 , 6 , 4 ));
List<Integer> arr2 = new ArrayList<>(List.of( 1 , 2 , 3 , 4 , 5 , 2 ));
System.out.println(maxMinDiff(arr1));
System.out.println(maxMinDiff(arr2));
}
}
|
Python3
def max_min_diff(arr):
n = len (arr)
i, j = 0 , 0
diff = 0
while j < n:
while j < n - 1 and arr[j] < arr[j + 1 ]:
j + = 1
diff + = arr[j] - arr[i]
i = j = j + 1
return diff
arr1 = [ 7 , 1 , 5 , 3 , 6 , 4 ]
arr2 = [ 1 , 2 , 3 , 4 , 5 , 2 ]
print (max_min_diff(arr1))
print (max_min_diff(arr2))
|
C#
using System;
using System.Collections.Generic;
class MaxMinDiffProgram {
static int MaxMinDiff(List< int > arr)
{
int n = arr.Count;
int i = 0, j = 0;
int diff = 0;
while (j < n) {
while (j < n - 1 && arr[j] < arr[j + 1]) {
j++;
}
diff += arr[j] - arr[i];
i = j = j + 1;
}
return diff;
}
static void Main()
{
List< int > arr1 = new List< int >{ 7, 1, 5, 3, 6, 4 };
List< int > arr2 = new List< int >{ 1, 2, 3, 4, 5, 2 };
Console.WriteLine(MaxMinDiff(arr1));
Console.WriteLine(MaxMinDiff(arr2));
}
}
|
Javascript
function maxMinDiff(arr) {
let n = arr.length;
let i = 0, j = 0;
let diff = 0;
while (j < n) {
while (j < n - 1 && arr[j] < arr[j + 1]) {
j++;
}
diff += arr[j] - arr[i];
i = j = j + 1;
}
return diff;
}
const arr1 = [7, 1, 5, 3, 6, 4];
const arr2 = [1, 2, 3, 4, 5, 2];
console.log(maxMinDiff(arr1));
console.log(maxMinDiff(arr2));
|
The time complexity of this approach is O(n)
the space complexity is O(1) as we are not using any extra space.
Last Updated :
13 Dec, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...