数组的连续元素之间的最小差值总和

给定一对数组，其中每对代表一个范围，任务是找到数组的连续元素之间的最小差值之和，其中以以下方式填充数组：

数组的每个元素都位于范围数组中其对应索引给出的范围内。
形成的数组中连续元素的最终差值之和最小。

例子：

Input: range[] = {{2, 4}, {3, 6}, {1, 5}, {1, 3}, {2, 7}}
Output: 0
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: 7
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.

编程需要懂一点英语

方法：采用贪心方法来解决上述问题。最初，我们必须以得到的差值之和最小的方式填充数组。贪心方法如下：

如果前一个索引的范围与当前索引的范围相交，那么在这种情况下，最小差将为0，并存储相交范围的最大值和最小值。
如果先前索引的范围的最小值大于当前索引的最大值，则在这种情况下，最小可能的总和是先前范围的最小值与当前范围中存储的最大值之间的差。
如果先前索引的最高范围低于当前范围的最低值，则最小总和是为当前索引存储的最低值与先前索引的最高范围之差。

下面是上述方法的实现：

C++

// C++ program for finding the minimum sum of
// difference between consecutive elements
#include 
using namespace std;
 
// function to find minimum sum of
// difference of consecutive element
int solve(pair 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 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

= $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

输出：

时间复杂度： O(N)
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。