给定数组中任何特殊对之间的最小距离

给定N个整数的数组arr [] ，任务是找到特殊对的索引之间的最小可能绝对差。

A special pair is defined as a pair of indices (i, j) such that if arr[i] ≤ arr[j], then there is no element X (where arr[i] < X < arr[j]) present in between indices i and j. 
For example: 
arr[] = {1, -5, 5} 
Here, {1, 5} forms a special pair as there are no elements in the range (1 to 5) in between arr[0] and arr[2].

打印最小绝对差abs(j – i) ，以使对(i，j)形成特殊对。

例子：

Input: arr[] = {0, -10, 5, -5, 1} 
Output: 2 
Explanation: 
The elements 1 and 5 forms a special pair since there is no elements X in the range 1 < X < 5 in between them, and they are 2 indices away from each other.

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

天真的方法：最简单的方法是考虑数组中的每一对元素，并检查它们是否形成特殊的对。如果发现是真的，则在所有形成的线对之间打印最小距离。

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

高效方法：为了优化上述方法，我们的想法是观察到我们仅需考虑排序数组中相邻元素位置之间的距离，因为那对元素之间将不具有任何值X。步骤如下：

1. 将数组元素的初始索引存储在Map中。
2. 对给定的数组arr []进行排序。
3. 现在，使用Map查找排序数组的相邻元素的索引之间的距离。
4. 在上述步骤中，为每对相邻元素保持最小距离。
5. 完成上述步骤后，打印形成的最小距离。

下面是上述方法的实现：

C++

// C++ program for the above approach 
#include  
using namespace std; 
  
// Function that finds the minimum 
// difference between two vectors 
int mindist(vector& left, 
            vector& right) 
{ 
    int res = INT_MAX; 
    for (int i = 0; i < left.size(); ++i) { 
  
        int num = left[i]; 
  
        // Find lower bound of the index 
        int index 
            = lower_bound(right.begin(), 
                        right.end(), num) 
            - right.begin(); 
  
        // Find two adjacent indices 
        // to take difference 
        if (index == 0) 
            res = min(res, 
                    abs(num 
                        - right[index])); 
  
        else if (index == right.size()) 
            res = min(res, 
                    abs(num 
                        - right[index - 1])); 
        else
            res = min(res, 
                    min(abs(num 
                            - right[index - 1]), 
                        abs(num 
                            - right[index]))); 
    } 
  
    // Return the result 
    return res; 
} 
  
// Function to find the minimum distance 
// between index of special pairs 
int specialPairs(vector& nums) 
{ 
    // Stores the index of each element 
    // in the array arr[] 
    map > m; 
    vector vals; 
  
    // Store the indexes 
    for (int i = 0; 
        i < nums.size(); ++i) { 
        m[nums[i]].insert(i); 
    } 
  
    // Get the unique values in list 
    for (auto p : m) { 
        vals.push_back(p.first); 
    } 
  
    int res = INT_MAX; 
  
    for (int i = 0; 
        i < vals.size(); ++i) { 
  
        vector vec(m[vals[i]].begin(), 
                        m[vals[i]].end()); 
  
        // Take adjacent difference 
        // of same values 
        for (int i = 1; 
            i < vec.size(); ++i) 
            res = min(res, 
                    abs(vec[i] 
                        - vec[i - 1])); 
  
        if (i) { 
            int a = vals[i]; 
  
            // Left index array 
            vector left(m[a].begin(), 
                            m[a].end()); 
  
            int b = vals[i - 1]; 
  
            // Right index array 
            vector right(m[b].begin(), 
                            m[b].end()); 
  
            // Find the minimum gap between 
            // the two adjacent different 
            // values 
            res = min(res, 
                    mindist(left, right)); 
        } 
    } 
    return res; 
} 
  
// Driver Code 
int main() 
{ 
    // Given array 
    vector arr{ 0, -10, 5, -5, 1 }; 
  
    // Function Call 
    cout << specialPairs(arr); 
  
    return 0; 
}

Python3

# Python3 program for the above approach
import sys
  
# Function that finds the minimum
# difference between two vectors
def mindist(left, right):
      
    res = sys.maxsize
      
    for i in range(len(left)):
        num = left[i]
          
        # Find lower bound of the index
        index = right.index(min(
                [i for i in right if num >= i]))
          
        # Find two adjacent indices
        # to take difference
        if (index == 0):
            res = min(res,
                  abs(num - right[index]))
        elif (index == len(right)):
            res = min(res, 
                  min(abs(num - right[index -1]),
                      abs(num - right[index])))
  
    # Return the result
    return res
      
# Function to find the minimum distance
# between index of special pairs
def specialPairs(nums):
      
    # Stores the index of each element
    # in the array arr[]
    m = {}
    vals = []
  
    for i in range(len(nums)):
        m[nums[i]] = i
          
    for p in m:
        vals.append(p)
      
    res = sys.maxsize
      
    for i in range(1, len(vals)):
        vec = [m[vals[i]]]
          
        # Take adjacent difference
        # of same values
        for i in range(1, len(vec)):
            res = min(res,
                      abs(vec[i] - vec[i - 1]))
              
        if (i):
            a = vals[i]
              
            # Left index array
            left = [m[a]]
              
            b = vals[i - 1]
              
            # Right index array
            right = [m[b]]
              
            # Find the minimum gap between
            # the two adjacent different
            # values
            res = min(res,
                      mindist(left, right)) + 1
      
    return res
  
# Driver Code
if __name__ == "__main__":
      
    # Given array 
    arr = [ 0, -10, 5, -5, 1 ]
  
    # Function call
    print(specialPairs(arr))
  
# This code is contributed by dadi madhav

输出：

2

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