Open In App

Sum of minimum difference between consecutive elements of an array

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:
 

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 chosen 
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 chosen 
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: 
 

Below is the implementation of the above approach: 
 




// 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;
 
    // initialize 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 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];
 
    // initialize 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 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
 
    # initialize 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# 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];
 
    // initialize 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 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];
 
// initialize 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
?>




<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];
   
    // initialize 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) 
 


Article Tags :