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

给定一个由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)

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