最小化相邻数组元素之间的绝对差之和所需的最小交换次数

给定一个由N 个不同的正整数组成的数组arr[] ，任务是找到需要交换的最小元素数，以最小化每对相邻元素的绝对差之和。

例子：

Input: arr[] = {8, 50, 11, 2}
Output: 2
Explanation:
Operation 1: Swapping of elements 8 and 2, modifies the array arr[] to {2, 50, 11, 8}.
Operation 2: Swapping of elements 8 and 50, modifies the array arr[] to {2, 8, 11, 50}.
The sum of absolute difference of adjacent elements of the modified array is 48, which is minimum.
Therefore, the minimum number of swaps required is 2. 

Input: arr[] = {3, 4, 2, 5, 1}
Output: 2

方法：如果数组按升序或降序排序，则可以基于以下观察来解决给定的问题：相邻元素的绝对差之和将最小。按照步骤解决问题。

• 使用本文中讨论的方法找出按升序对给定数组进行排序所需的最小交换次数。让计数为S1 。
• 使用本文中讨论的方法，找出按降序对给定数组进行排序所需的最小交换次数。让计数为S2 。
• 完成上述步骤后，打印值S1和S2中的最小值作为所需的最小交换次数。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Comparator to sort in the descending
// order
bool mycmp(pair a,
           pair b)
{
    return a.first > b.first;
}
 
// Function to find the minimum number
// of swaps required to sort the array
// in increasing order
int minSwapsAsc(vector arr, int n)
{
    // Stores the array elements with
    // its index
    pair arrPos[n];
    for (int i = 0; i < n; i++) {
        arrPos[i].first = arr[i];
        arrPos[i].second = i;
    }
 
    // Sort the array in the
    // increasing order
    sort(arrPos, arrPos + n);
 
    // Keeps the track of
    // visited elements
    vector vis(n, false);
 
    // Stores the count of swaps required
    int ans = 0;
 
    // Traverse array elements
    for (int i = 0; i < n; i++) {
 
        // If the element is already
        // swapped or at correct position
        if (vis[i] || arrPos[i].second == i)
            continue;
 
        // Find out the number of
        // nodes in this cycle
        int cycle_size = 0;
 
        // Update the value of j
        int j = i;
 
        while (!vis[j]) {
            vis[j] = 1;
 
            // Move to the next element
            j = arrPos[j].second;
 
            // Increment cycle_size
            cycle_size++;
        }
 
        // Update the ans by adding
        // current cycle
        if (cycle_size > 0) {
            ans += (cycle_size - 1);
        }
    }
 
    return ans;
}
 
// Function to find the minimum number
// of swaps required to sort the array
// in decreasing order
int minSwapsDes(vector arr, int n)
{
    // Stores the array elements with
    // its index
    pair arrPos[n];
 
    for (int i = 0; i < n; i++) {
        arrPos[i].first = arr[i];
        arrPos[i].second = i;
    }
 
    // Sort the array in the
    // descending order
    sort(arrPos, arrPos + n, mycmp);
 
    // Keeps track of visited elements
    vector vis(n, false);
 
    // Stores the count of resultant
    // swap required
    int ans = 0;
 
    // Traverse array elements
    for (int i = 0; i < n; i++) {
 
        // If the element is already
        // swapped or at correct
        // position
        if (vis[i] || arrPos[i].second == i)
            continue;
 
        // Find out the number of
        // node in this cycle
        int cycle_size = 0;
 
        // Update the value of j
        int j = i;
 
        while (!vis[j]) {
 
            vis[j] = 1;
 
            // Move to the next element
            j = arrPos[j].second;
 
            // Increment the cycle_size
            cycle_size++;
        }
 
        // Update the ans by adding
        // current cycle size
        if (cycle_size > 0) {
            ans += (cycle_size - 1);
        }
    }
 
    return ans;
}
 
// Function to find minimum number of
// swaps required to minimize the sum
// of absolute difference of adjacent
// elements
int minimumSwaps(vector arr)
{
    // Sort in ascending order
    int S1 = minSwapsAsc(arr, arr.size());
 
    // Sort in descending order
    int S2 = minSwapsDes(arr, arr.size());
 
    // Return the minimum value
    return min(S1, S2);
}
 
// Drive Code
int main()
{
    vector arr{ 3, 4, 2, 5, 1 };
    cout << minimumSwaps(arr);
 
    return 0;
}

Java

// Java program for the above approach
import java.lang.*;
import java.util.*;
 
// Pair class
class pair
{
    int first, second;
    pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
}
 
class GFG{
 
// Function to find the minimum number
// of swaps required to sort the array
// in increasing order
static int minSwapsAsc(int[] arr, int n)
{
     
    // Stores the array elements with
    // its index
    pair[] arrPos = new pair[n];
    for(int i = 0; i < n; i++)
    {
        arrPos[i] = new pair(arr[i], i);
    }
 
    // Sort the array in the
    // increasing order
    Arrays.sort(arrPos, (a, b)-> a.first - b.first);
 
    // Keeps the track of
    // visited elements
    boolean[] vis= new boolean[n];
 
    // Stores the count of swaps required
    int ans = 0;
 
    // Traverse array elements
    for(int i = 0; i < n; i++)
    {
         
        // If the element is already
        // swapped or at correct position
        if (vis[i] || arrPos[i].second == i)
            continue;
 
        // Find out the number of
        // nodes in this cycle
        int cycle_size = 0;
 
        // Update the value of j
        int j = i;
 
        while (!vis[j])
        {
            vis[j] = true;
 
            // Move to the next element
            j = arrPos[j].second;
 
            // Increment cycle_size
            cycle_size++;
        }
 
        // Update the ans by adding
        // current cycle
        if (cycle_size > 0)
        {
            ans += (cycle_size - 1);
        }
    }
    return ans;
}
 
// Function to find the minimum number
// of swaps required to sort the array
// in decreasing order
static int minSwapsDes(int[] arr, int n)
{
     
    // Stores the array elements with
    // its index
    pair[] arrPos = new pair[n];
 
    for(int i = 0; i < n; i++)
    {
        arrPos[i] = new pair(arr[i], i);
    }
 
    // Sort the array in the
    // descending order
    Arrays.sort(arrPos, (a, b)-> b.first - a.first);
 
    // Keeps track of visited elements
    boolean[] vis = new boolean[n];
 
    // Stores the count of resultant
    // swap required
    int ans = 0;
 
    // Traverse array elements
    for(int i = 0; i < n; i++)
    {
         
        // If the element is already
        // swapped or at correct
        // position
        if (vis[i] || arrPos[i].second == i)
            continue;
 
        // Find out the number of
        // node in this cycle
        int cycle_size = 0;
 
        // Update the value of j
        int j = i;
 
        while (!vis[j])
        {
             
            vis[j] = true;
 
            // Move to the next element
            j = arrPos[j].second;
 
            // Increment the cycle_size
            cycle_size++;
        }
 
        // Update the ans by adding
        // current cycle size
        if (cycle_size > 0)
        {
            ans += (cycle_size - 1);
        }
    }
    return ans;
}
 
// Function to find minimum number of
// swaps required to minimize the sum
// of absolute difference of adjacent
// elements
static int minimumSwaps(int[] arr)
{
     
    // Sort in ascending order
    int S1 = minSwapsAsc(arr, arr.length);
 
    // Sort in descending order
    int S2 = minSwapsDes(arr, arr.length);
 
    // Return the minimum value
    return Math.min(S1, S2);
}
 
// Driver code
public static void main(String[] args)
{
    int[] arr = { 3, 4, 2, 5, 1 };
    System.out.println(minimumSwaps(arr));
}
}
 
// This code is contributed by offbeat

Python3

# Python3 program for the above approach
 
# Function to find the minimum number
# of swaps required to sort the array
# in increasing order
def minSwapsAsc(arr, n):
     
    # Stores the array elements with
    # its index
    arrPos = [[arr[i], i] for i in range(n)]
 
    # Sort the array in the
    # increasing order
    arrPos = sorted(arrPos)
 
    # Keeps the track of
    # visited elements
    vis = [False] * (n)
 
    # Stores the count of swaps required
    ans = 0
 
    # Traverse array elements
    for i in range(n):
         
        # If the element is already
        # swapped or at correct position
        if (vis[i] or arrPos[i][1] == i):
            continue
 
        # Find out the number of
        # nodes in this cycle
        cycle_size = 0
 
        # Update the value of j
        j = i
 
        while (not vis[j]):
            vis[j] = 1
 
            # Move to the next element
            j = arrPos[j][1]
 
            # Increment cycle_size
            cycle_size += 1
 
        # Update the ans by adding
        # current cycle
        if (cycle_size > 0):
            ans += (cycle_size - 1)
 
    return ans
 
# Function to find the minimum number
# of swaps required to sort the array
# in decreasing order
def minSwapsDes(arr, n):
     
    # Stores the array elements with
    # its index
    arrPos = [[0, 0] for i in range(n)]
 
    for i in range(n):
        arrPos[i][0] = arr[i]
        arrPos[i][1] = i
 
    # Sort the array in the
    # descending order
    arrPos = sorted(arrPos)[::-1]
 
    # Keeps track of visited elements
    vis = [False] * n
 
    # Stores the count of resultant
    # swap required
    ans = 0
 
    # Traverse array elements
    for i in range(n):
         
        # If the element is already
        # swapped or at correct
        # position
        if (vis[i] or arrPos[i][1] == i):
            continue
 
        # Find out the number of
        # node in this cycle
        cycle_size = 0
 
        # Update the value of j
        j = i
 
        while (not vis[j]):
            vis[j] = 1
 
            # Move to the next element
            j = arrPos[j][1]
 
            # Increment the cycle_size
            cycle_size += 1
 
        # Update the ans by adding
        # current cycle size
        if (cycle_size > 0):
            ans += (cycle_size - 1)
             
    return ans
 
# Function to find minimum number of
# swaps required to minimize the sum
# of absolute difference of adjacent
# elements
def minimumSwaps(arr):
     
    # Sort in ascending order
    S1 = minSwapsAsc(arr, len(arr))
 
    # Sort in descending order
    S2 = minSwapsDes(arr, len(arr))
 
    # Return the minimum value
    return min(S1, S2)
 
# Drive Code
if __name__ == '__main__':
     
    arr = [ 3, 4, 2, 5, 1 ]
    print (minimumSwaps(arr))
 
# This code is contributed by mohit kumar 29

Javascript

        // Javascript program for the above approach
 
        // Comparator to sort in the descending
        // order
        function mycmp(a, b) {
            return a[0] > b[0];
        }
 
        // Function to find the minimum number
        // of swaps required to sort the array
        // in increasing order
        function minSwapsAsc(arr, n) {
            // Stores the array elements with
            // its index
            let arrPos = new Array(n);
            for (let i = 0; i < n; i++)
                arrPos[i] = new Array(2);
 
            for (let i = 0; i < n; i++) {
                arrPos[i][0] = arr[i];
                arrPos[i][1] = i;
            }
 
            // Sort the array in the
            // increasing order
            arrPos.sort(function (a, b) { return a[0] - b[0] })
 
            // Keeps the track of
            // visited elements
            let vis = new Array(n);
            for (let i = 0; i < n; i++)
                vis[i] = false
 
            // Stores the count of swaps required
            let ans = 0;
 
            // Traverse array elements
            for (let i = 0; i < n; i++) {
 
                // If the element is already
                // swapped or at correct position
                if (vis[i] || arrPos[i][1] == i)
                    continue;
 
                // Find out the number of
                // nodes in this cycle
                let cycle_size = 0;
 
                // Update the value of j
                let j = i;
 
                while (!vis[j]) {
                    vis[j] = 1;
 
                    // Move to the next element
                    j = arrPos[j][1];
 
                    // Increment cycle_size
                    cycle_size++;
                }
 
                // Update the ans by adding
                // current cycle
                if (cycle_size > 0) {
                    ans += (cycle_size - 1);
                }
            }
 
            return ans;
        }
 
        // Function to find the minimum number
        // of swaps required to sort the array
        // in decreasing order
        function minSwapsDes(arr, n) {
            // Stores the array elements with
            // its index
            let arrPos = new Array(n);
            for (let i = 0; i < n; i++)
                arrPos[i] = new Array(2);
 
            for (let i = 0; i < n; i++) {
                arrPos[i][0] = arr[i];
                arrPos[i][1] = i;
            }
 
            // Sort the array in the
            // descending order
            arrPos.sort(function (a, b) { return b[0] - a[0] })
 
            // Keeps track of visited elements
            let vis = new Array(n);
            for (let i = 0; i < n; i++)
                vis[i] = false
 
            // Stores the count of resultant
            // swap required
            let ans = 0;
 
            // Traverse array elements
            for (let i = 0; i < n; i++) {
 
                // If the element is already
                // swapped or at correct
                // position
                if (vis[i] || arrPos[i][1] == i)
                    continue;
 
                // Find out the number of
                // node in this cycle
                let cycle_size = 0;
 
                // Update the value of j
                let j = i;
 
                while (!vis[j]) {
 
                    vis[j] = 1;
 
                    // Move to the next element
                    j = arrPos[j][1];
 
                    // Increment the cycle_size
                    cycle_size++;
                }
 
                // Update the ans by adding
                // current cycle size
                if (cycle_size > 0) {
                    ans += (cycle_size - 1);
                }
            }
 
            return ans;
        }
 
        // Function to find minimum number of
        // swaps required to minimize the sum
        // of absolute difference of adjacent
        // elements
        function minimumSwaps(arr) {
            // Sort in ascending order
            let S1 = minSwapsAsc(arr, arr.length);
 
            // Sort in descending order
            let S2 = minSwapsDes(arr, arr.length);
 
            // Return the minimum value
            return Math.min(S1, S2);
        }
 
        // Drive Code
 
        let arr = [ 3, 4, 2, 5, 1 ];
        document.write(minimumSwaps(arr));
 
        // This code is contributed by Hritik
    

输出：

2

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

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live