阵列中任何最频繁和最不频繁的元素之间的最小距离

给定大小为N的整数数组arr [] ，任务是找到给定数组中任何最频繁和最不频繁的元素之间的最小距离。

例子：

Input: arr[] = {1, 1, 2, 3, 2, 3, 3}
Output: 1
Explanation: The least frequent elements are 1 and 2 which occurs at indexes: 0, 1, 2, 4. 
Whereas, the most frequent element is 3 which occurs at indexes: 3, 5, 6.
So the minimum distance is (3-2) = 1.

Input: arr[] = {1, 3, 4, 4, 3, 4}
Output: 2
Explanation: The least frequent element is 1 which occurs at indexes: 0. 
Whereas, the most frequent element is 4 which occurs at indexes: 2, 3, 5. 
So the minimum distance is (2-0) = 2.
 

方法：想法是找到数组中最少和最频繁元素的索引，并找到这些索引之间的最小差。请按照以下步骤解决问题：

1. 将每个元素的频率存储在HashMap中。
2. 将最少和最频繁的元素存储在单独的集中。
3. 从数组的开头开始遍历。如果当前元素是最不频繁元素，则更新最不频繁元素的最后索引。
4. 否则，如果当前元素是最频繁元素，则计算当前元素与最不频繁元素的最后索引之间的距离，并更新所需的最小距离。
5. 同样，从末尾遍历数组，然后重复步骤3和步骤4，以找到数组中任何最频繁和最不频繁的元素之间的最小距离。
6. 打印最小距离。

下面是上述方法的实现：

Java

// Java implementation of the approach
import java.util.*;
 
class GFG {
 
    // Function to find the minimum
    // distance between any two most
    // and least frequent element
    public static void
    getMinimumDistance(int a[], int n)
    {
 
        // Initialize sets to store the least
        // and the most frequent elements
        Set min_set = new HashSet<>();
        Set max_set = new HashSet<>();
 
        // Initialize variables to store
        // max and min frequency
        int max = 0, min = Integer.MAX_VALUE;
 
        // Initialize HashMap to store
        // frequency of each element
        HashMap frequency
            = new HashMap<>();
 
        // Loop through the array
        for (int i = 0; i < n; i++) {
 
            // Store the count of each element
            frequency.put(
                a[i],
                frequency
                        .getOrDefault(a[i], 0)
                    + 1);
        }
 
        // Store the least and most frequent
        // elements in the respective sets
        for (int i = 0; i < n; i++) {
 
            // Store count of current element
            int count = frequency.get(a[i]);
 
            // If count is equal
            // to max count
            if (count == max) {
 
                // Store in max set
                max_set.add(a[i]);
            }
 
            // If count is greater
            // then max count
            else if (count > max) {
 
                // Empty max set
                max_set.clear();
 
                // Update max count
                max = count;
 
                // Store in max set
                max_set.add(a[i]);
            }
 
            // If count is equal
            // to min count
            if (count == min) {
 
                // Store in min set
                min_set.add(a[i]);
            }
 
            // If count is less
            // then max count
            else if (count < min) {
 
                // Empty min set
                min_set.clear();
 
                // Update min count
                min = count;
 
                // Store in min set
                min_set.add(a[i]);
            }
        }
 
        // Initialize a variable to
        // store the minimum distance
        int min_dist = Integer.MAX_VALUE;
 
        // Initialize a variable to
        // store the last index of
        // least frequent element
        int last_min_found = -1;
 
        // Traverse array
        for (int i = 0; i < n; i++) {
 
            // If least frequent element
            if (min_set.contains(a[i]))
 
                // Update last index of
                // least frequent element
                last_min_found = i;
 
            // If most frequent element
            if (max_set.contains(a[i])
                && last_min_found != -1) {
 
                // Update minimum distance
                min_dist = Math.min(min_dist,
                                    i - last_min_found);
            }
        }
 
        last_min_found = -1;
 
        // Traverse array from the end
        for (int i = n - 1; i >= 0; i--) {
 
            // If least frequent element
            if (min_set.contains(a[i]))
 
                // Update last index of
                // least frequent element
                last_min_found = i;
 
            // If most frequent element
            if (max_set.contains(a[i])
                && last_min_found != -1) {
 
                // Update minimum distance
                min_dist = Math.min(min_dist,
                                    last_min_found - i);
            }
        }
 
        // Print the minimum distance
        System.out.println(min_dist);
    }
 
    // Driver Code
    public static void
        main(String[] args)
    {
        // Given array
        int arr[] = { 1, 1, 2, 3, 2, 3, 3 };
 
        int N = arr.length;
 
        // Function Call
        getMinimumDistance(arr, N);
    }
}

Python3

# Python3 implementation of the approach
import sys
 
# Function to find the minimum
# distance between any two most
# and least frequent element
def getMinimumDistance(a, n):
     
    # Initialize sets to store the least
    # and the most frequent elements
    min_set = {}
    max_set = {}
 
    # Initialize variables to store
    # max and min frequency
    max, min = 0, sys.maxsize + 1
 
    # Initialize HashMap to store
    # frequency of each element
    frequency = {}
 
    # Loop through the array
    for i in range(n):
         
        # Store the count of each element
        frequency[a[i]] = frequency.get(a[i], 0) + 1
 
    # Store the least and most frequent
    # elements in the respective sets
    for i in range(n):
         
        # Store count of current element
        count = frequency[a[i]]
 
        # If count is equal
        # to max count
        if (count == max):
             
            # Store in max set
            max_set[a[i]] = 1
             
        # If count is greater
        # then max count
        elif (count > max):
             
            # Empty max set
            max_set.clear()
 
            # Update max count
            max = count
 
            # Store in max set
            max_set[a[i]] = 1
             
        # If count is equal
        # to min count
        if (count == min):
 
            # Store in min set
            min_set[a[i]] = 1
             
        # If count is less
        # then max count
        elif (count < min):
             
            # Empty min set
            min_set.clear()
 
            # Update min count
            min = count
 
            # Store in min set
            min_set[a[i]] = 1
 
    # Initialize a variable to
    # store the minimum distance
    min_dist = sys.maxsize + 1
 
    # Initialize a variable to
    # store the last index of
    # least frequent element
    last_min_found = -1
 
    # Traverse array
    for i in range(n):
         
        # If least frequent element
        if (a[i] in min_set):
             
            # Update last index of
            # least frequent element
            last_min_found = i
 
        # If most frequent element
        if ((a[i] in max_set) and
            last_min_found != -1):
 
            # Update minimum distance
            if i-last_min_found < min_dist:
                min_dist = i - last_min_found
                 
    last_min_found = -1
 
    # Traverse array from the end
    for i in range(n - 1, -1, -1):
         
        # If least frequent element
        if (a[i] in min_set):
             
            # Update last index of
            # least frequent element
            last_min_found = i;
 
        # If most frequent element
        if ((a[i] in max_set) and
            last_min_found != -1):
 
            # Update minimum distance
            if min_dist > last_min_found - i:
                min_dist = last_min_found - i
 
    # Print the minimum distance
    print(min_dist)
 
# Driver Code
if __name__ == '__main__':
     
    # Given array
    arr = [ 1, 1, 2, 3, 2, 3, 3 ]
 
    N = len(arr)
 
    # Function Call
    getMinimumDistance(arr, N)
 
# This code is contributed by mohit kumar 29

输出：

1

时间复杂度： O(N)，其中N是数组的长度。
辅助空间： O(N)