数组中元素的第一个和最后一个索引之间的最大差异

给定一个由 n 个整数组成的数组。任务是找到每个不同元素的第一个和最后一个索引的差异，以使差异最大化。

例子：

Input : {2, 1, 3, 4, 2, 1, 5, 1, 7}
Output : 6
Element 1 has its first index = 1
and last index = 7
Difference = 7 - 1 = 6
Other elements have a smaller first and last
index difference

Input : {2, 2, 1, 1, 8, 8, 3, 5, 3} 
Output : 2
Maximum difference is for indexes of element 3.

一个简单的方法是运行两个循环并找到每个元素的差异并相应地更新max_diff 。它的时间复杂度为 O(n ² )，并且该方法还需要跟踪已访问过的元素，以免不必要地计算它们的差异。

一种有效的方法是使用散列。它有以下步骤。

1. 从左到右遍历输入数组。
2. 对于每个不同的元素，映射它在哈希表中的第一个和最后一个索引。
3. 遍历哈希表，计算每个元素的首尾索引差。
4. 相应地更新max_diff 。

在以下实现中 unordered_map 已用于散列，因为整数范围未知。

C++

// C++ implementation to find the maximum difference 
// of first and last index of array elements
#include 
  
using namespace std;
  
// function to find the
// maximum difference
int maxDifference(int arr[], int n)
{
    // structure to store first and last
    // index of each distinct element
    struct index
    {
        int f, l;
    };
      
    // maps each element to its
    // 'index' structure
    unordered_map um;
      
    for (int i=0; i::iterator itr;
  
    // traversing 'um'
    for (itr=um.begin(); itr != um.end(); itr++)
    {   
        // difference of last and first index
        // of each element
        diff = (itr->second).l - (itr->second).f;
          
        // update 'max_dff'
        if (max_diff < diff)
            max_diff = diff;
    }
      
    // required maximum difference
    return max_diff;
}
  
  
// Driver program to test above
int main()
{
    int arr[] = {2, 1, 3, 4, 2, 1, 5, 1, 7};
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Maximum Difference = " 
         <

---

Java

// Java implementation to find the maximum difference 
// of first and last index of array elements
import java.util.HashMap;
import java.util.Map;
  
public class MaxDiffIndexHashing {
  
    static class Element {
        int first;
        int second;
  
        public Element() {
            super();
        }
  
        public Element(int first, int second) {
            super();
            this.first = first;
            this.second = second;
        }
    }
  
    public static void main(String[] args) {
  
        int arr[]={2, 1, 3, 4, 2, 1, 5, 1, 7};
        System.out.println("Maximum Difference= "+ maxDiffIndices(arr));
    }
  
    private static int maxDiffIndices(int[] arr) {
        int n = arr.length;
        int maxDiffIndex = 0;
        Map map = new HashMap();
  
        for (int i = 0; i < n; i++) {
            if (map.containsKey(arr[i])) {
                Element e = map.get(arr[i]);
                e.second = i;
            } else {
                Element e = new Element();
                e.first = i;
                map.put(arr[i], e);
            }
  
        }
  
        for (Map.Entry entry : map.entrySet()) {
            Element e = entry.getValue();
            if ((e.second - e.first) > maxDiffIndex)
                maxDiffIndex = e.second - e.first;
        }
  
        return maxDiffIndex;
    }
  
}

C#

// C# implementation to find the maximum difference 
// of first and last index of array elements 
using System;
using System.Collections.Generic;
  
public class MaxDiffIndexHashing 
{ 
  
    class Element { 
        public int first; 
        public int second; 
  
        public Element() { 
        } 
  
        public Element(int first, int second) { 
            this.first = first; 
            this.second = second; 
        } 
    } 
  
    public static void Main(String[] args) { 
  
        int []arr={2, 1, 3, 4, 2, 1, 5, 1, 7}; 
        Console.WriteLine("Maximum Difference= "+ maxDiffIndices(arr)); 
    } 
  
    private static int maxDiffIndices(int[] arr) { 
        int n = arr.Length; 
        int maxDiffIndex = 0; 
        Dictionary map = new Dictionary(); 
  
        for (int i = 0; i < n; i++) { 
            if (map.ContainsKey(arr[i])) { 
                Element e = map[arr[i]]; 
                e.second = i; 
            } else { 
                Element e = new Element(); 
                e.first = i; 
                map.Add(arr[i], e); 
            } 
  
        } 
  
        foreach(KeyValuePair entry in map) { 
            Element e = entry.Value; 
            if ((e.second - e.first) > maxDiffIndex) 
                maxDiffIndex = e.second - e.first; 
        } 
  
        return maxDiffIndex; 
    } 
}     
  
// This code is contributed by 29AjayKumar

输出：

Maximum Difference = 6

时间复杂度：O(n)

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