Skip to content
Related Articles

Related Articles

Improve Article
Sum of minimum difference between consecutive elements of an array
  • Difficulty Level : Medium
  • Last Updated : 21 May, 2021

Given an array of pairs where each pair represents a range, the task is to find the sum of the minimum difference between the consecutive elements of an array where the array is filled in the below manner:
 

  • Each element of an array lies in the range given at its corresponding index in the range array.
  • Final sum of difference of consecutive elements in the array formed is minimum.

Examples: 
 

Input: range[] = {{2, 4}, {3, 6}, {1, 5}, {1, 3}, {2, 7}} 
Output:
The result is 0 because the array {3, 3, 3, 3, 3} is choosen 
then the sum of difference of consecutive element will be 
{ |3-3| + |3-3| + |3-3| + |3-3| } = 0 which the minimum. 
Input: range[] = {{1, 3}, {2, 5}, {6, 8}, {1, 2}, {2, 3}} 
Output:
The result is 7 because if the array {3, 3, 6, 2, 2} is choosen 
then the sum of difference of consecutive element will be 
{ |3-3| + |6-3| + |2-6| + |2-2| }= 7 which is the minimum.

 

Approach: A greedy approach has been followed to solve the above problem. Initially, we have to fill the array in such a way that the sum of the difference obtained is minimum. The greedy approach is as follows: 
 



  • If the range of the previous index intersects the range of current index then, in this case, the minimum difference will be 0 and store the highest value and the lowest value of intersecting range.
  • If the lowest value of the range of the previous index is greater than the highest value for the current index then in this case the least possible sum is the difference in the lowest value of the previous range and the highest value stored in the current range.
  • If the highest range of the previous index is lower than the lowest value of current range then the minimum sum is the difference in the lowest value stored for the current index and the highest range of the previous index.

Below is the implementation of the above approach: 
 

C++




// C++ program for finding the minimum sum of
// difference between consecutive elements
#include <bits/stdc++.h>
using namespace std;
 
// function to find minimum sum of
// difference of consecutive element
int solve(pair<int, int> v[], int n)
{
    // ul to store upper limit
    // ll to store lower limit
    int ans, ul, ll;
 
    // storethe lower range in ll
    // and upper range in ul
    ll = v[0].first;
    ul = v[0].second;
 
    // inititalize the answer with 0
    ans = 0;
 
    // iterate for all ranges
    for (int i = 1; i < n; i++) {
 
        // case 1, in this case the difference will be 0
        if ((v[i].first <= ul && v[i].first >= ll) ||
           (v[i].second >= ll && v[i].second <= ul)) {
 
            // change upper limit and lower limit
            if (v[i].first > ll) {
                ll = v[i].first;
            }
            if (v[i].second < ul) {
                ul = v[i].second;
            }
        }
 
        // case 2
        else if (v[i].first > ul) {
 
            // store the difference
            ans += abs(ul - v[i].first);
            ul = v[i].first;
            ll = v[i].first;
        }
 
        // case 3
        else if (v[i].second < ll) {
 
            // store the difference
            ans += abs(ll - v[i].second);
            ul = v[i].second;
            ll = v[i].second;
        }
    }
    return ans;
}
// Driver code
int main()
{
    // array of range
 
    pair<int, int> v[] = { { 1, 3 }, { 2, 5 },
                { 6, 8 }, { 1, 2 }, { 2, 3 } };
    int n = sizeof(v) / sizeof(v[0]);
    cout << solve(v, n) << endl;
 
    return 0;
}

Java




// Java program for finding the
// minimum sum of difference
// between consecutive elements
import java.io.*;
 
class GFG
{
     
// function to find minimum
// sum of difference of
// consecutive element
static int solve(int[][] v, int n)
{
    // ul to store upper limit
    // ll to store lower limit
    int ans, ul, ll;
    int first = 0;
    int second = 1;
 
    // storethe lower range
    // in ll and upper range
    // in ul
    ll = v[0][first];
    ul = v[0][second];
 
    // inititalize the
    // answer with 0
    ans = 0;
 
    // iterate for all ranges
    for (int i = 1; i < n; i++)
    {
 
        // case 1, in this case
        // the difference will be 0
        if ((v[i][first] <= ul &&
              v[i][first] >= ll) ||
            (v[i][second] >= ll &&
             v[i][second] <= ul))
        {
 
            // change upper limit
            // and lower limit
            if (v[i][first] > ll)
            {
                ll = v[i][first];
            }
            if (v[i][second] < ul)
            {
                ul = v[i][second];
            }
        }
 
        // case 2
        else if (v[i][first] > ul)
        {
 
            // store the difference
            ans += Math.abs(ul - v[i][first]);
            ul = v[i][first];
            ll = v[i][first];
        }
 
        // case 3
        else if (v[i][second] < ll)
        {
 
            // store the difference
            ans += Math.abs(ll - v[i][second]);
            ul = v[i][second];
            ll = v[i][second];
        }
    }
    return ans;
}
 
// Driver code
public static void main(String []args)
{
    // array of range
 
    int[][] v = {{ 1, 3 }, { 2, 5 },
                 { 6, 8 }, { 1, 2 },
                 { 2, 3 }};
    int n = 5;
    System.out.println(solve(v, n));
}
}
 
// This code is contributed
// by chandan_jnu

Python




# Python program for finding
# the minimum sum of difference
# between consecutive elements
 
class pair:
    first = 0
    second = 0
     
    def __init__(self, a, b):
        self.first = a
        self.second = b
 
# function to find minimum
# sum of difference of
# consecutive element
def solve(v, n):
     
    # ul to store upper limit
    # ll to store lower limit
    ans = 0; ul = 0; ll = 0;
 
    # storethe lower range
    # in ll and upper range
    # in ul
    ll = v[0].first
    ul = v[0].second
 
    # inititalize the
    # answer with 0
    ans = 0
 
    # iterate for all ranges
    for i in range(1, n):
         
        # case 1, in this case
        # the difference will be 0
        if (v[i].first <= ul and
            v[i].first >= ll) or \
           (v[i].second >= ll and
            v[i].second <= ul):
             
            # change upper limit
            # and lower limit
            if v[i].first > ll:
                ll = v[i].first
             
            if v[i].second < ul:
                ul = v[i].second;
 
        # case 2
        elif v[i].first > ul:
             
            # store the difference
            ans += abs(ul - v[i].first)
            ul = v[i].first
            ll = v[i].first
 
        # case 3
        elif v[i].second < ll:
             
            # store the difference
            ans += abs(ll - v[i].second);
            ul = v[i].second;
            ll = v[i].second;
    return ans
 
# Driver code
 
# array of range
v = [pair(1, 3), pair(2, 5),
     pair(6, 8), pair(1, 2),
                 pair(2, 3) ]
n = len(v)
print(solve(v, n))
 
# This code is contributed
# by Harshit Saini

C#




// C# program for finding the
// minimum sum of difference
// between consecutive elements
using System;
 
class GFG
{
// function to find minimum
// sum of difference of
// consecutive element
static int solve(int[,] v, int n)
{
    // ul to store upper limit
    // ll to store lower limit
    int ans, ul, ll;
    int first = 0;
    int second = 1;
 
    // storethe lower range
    // in ll and upper range
    // in ul
    ll = v[0, first];
    ul = v[0, second];
 
    // inititalize the
    // answer with 0
    ans = 0;
 
    // iterate for all ranges
    for (int i = 1; i < n; i++)
    {
 
        // case 1, in this case
        // the difference will be 0
        if ((v[i, first] <= ul &&
             v[i, first] >= ll) ||
            (v[i, second] >= ll &&
             v[i, second] <= ul))
        {
 
            // change upper limit
            // and lower limit
            if (v[i, first] > ll)
            {
                ll = v[i, first];
            }
            if (v[i, second] < ul)
            {
                ul = v[i, second];
            }
        }
 
        // case 2
        else if (v[i, first] > ul)
        {
 
            // store the difference
            ans += Math.Abs(ul - v[i, first]);
            ul = v[i, first];
            ll = v[i, first];
        }
 
        // case 3
        else if (v[i, second] < ll)
        {
 
            // store the difference
            ans += Math.Abs(ll - v[i, second]);
            ul = v[i, second];
            ll = v[i, second];
        }
    }
    return ans;
}
 
// Driver code
static void Main()
{
    // array of range
 
    int[,] v = new int[5,2]{ { 1, 3 }, { 2, 5 },
                             { 6, 8 }, { 1, 2 },
                             { 2, 3 } };
    int n = 5;
    Console.WriteLine(solve(v, n));
}
}
 
// This code is contributed
// by chandan_jnu
        

PHP




<?php
// PHP program for finding the
// minimum sum of difference
// between consecutive elements
 
// function to find minimum
// sum of difference of
// consecutive element
function solve($v, $n)
{
// ul to store upper limit
// ll to store lower limit
$ans; $ul; $ll;
$first = 0;
$second = 1;
 
// storethe lower range
// in ll and upper range
// in ul
$ll = $v[0][$first];
$ul = $v[0][$second];
 
// inititalize the
// answer with 0
$ans = 0;
 
// iterate for all ranges
for ($i = 1; $i <$n; $i++)
{
 
    // case 1, in this case
    // the difference will be 0
    if (($v[$i][$first] <= $ul and
         $v[$i][$first] >= $ll) or
        ($v[$i][$second] >= $ll and
         $v[$i][$second] <= $ul))
    {
 
        // change upper limit
        // and lower limit
        if ($v[$i][$first] > $ll)
        {
            $ll = $v[$i][$first];
        }
        if ($v[$i][$second] < $ul)
        {
            $ul = $v[$i][$second];
        }
    }
 
    // case 2
    else if ($v[$i][$first] > $ul)
    {
 
        // store the difference
        $ans += abs($ul - $v[$i][$first]);
        $ul = $v[$i][$first];
        $ll = $v[$i][$first];
    }
 
    // case 3
    else if ($v[$i][$second] < $ll)
    {
 
        // store the difference
        $ans += abs($ll - $v[$i][$second]);
        $ul = $v[$i][$second];
        $ll = $v[$i][$second];
    }
}
return $ans;
}
 
// Driver code
 
// array of range
$v = array(array( 1, 3 ),
           array( 2, 5 ),
           array( 6, 8 ),
           array( 1, 2 ),
           array( 2, 3 ));
$n = 5;
echo(solve($v, $n));
 
// This code is contributed
// by chandan_jnu
?>

Javascript




<script>
 
// JavaScript program for finding the
// minimum sum of difference
// between consecutive elements
 
// function to find minimum
// sum of difference of
// consecutive element
function solve(v, n)
{
    // ul to store upper limit
    // ll to store lower limit
    let ans, ul, ll;
    let first = 0;
    let second = 1;
   
    // storethe lower range
    // in ll and upper range
    // in ul
    ll = v[0][first];
    ul = v[0][second];
   
    // inititalize the
    // answer with 0
    ans = 0;
   
    // iterate for all ranges
    for (let i = 1; i < n; i++)
    {
   
        // case 1, in this case
        // the difference will be 0
        if ((v[i][first] <= ul &&
              v[i][first] >= ll) ||
            (v[i][second] >= ll &&
             v[i][second] <= ul))
        {
   
            // change upper limit
            // and lower limit
            if (v[i][first] > ll)
            {
                ll = v[i][first];
            }
            if (v[i][second] < ul)
            {
                ul = v[i][second];
            }
        }
   
        // case 2
        else if (v[i][first] > ul)
        {
   
            // store the difference
            ans += Math.abs(ul - v[i][first]);
            ul = v[i][first];
            ll = v[i][first];
        }
   
        // case 3
        else if (v[i][second] < ll)
        {
   
            // store the difference
            ans += Math.abs(ll - v[i][second]);
            ul = v[i][second];
            ll = v[i][second];
        }
    }
    return ans;
}
 
// driver code
 
     let v = [[ 1, 3 ], [ 2, 5 ],
              [ 6, 8 ], [ 1, 2 ],
              [ 2, 3 ]];
    let n = 5;
    document.write(solve(v, n));
 
   
</script>
Output: 
7

 

Time Complexity: O(N) 
Auxiliary Space: O(1) 
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :