以最佳時間復雜度 [Java] 在未排序的整數數組中找到兩個相同數字之間的最大差異

Question

static int solution(int[] A) {
    int N = A.length;
    int result = 0;
    Map<Integer, List<Integer>> map = new TreeMap<>();
    for (int i = 0; i < N; i++) {
        List<Integer> list = map.getOrDefault(A[i], new ArrayList<>());
        list.add(i);
        map.put(A[i], list);

    }
    for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
        List<Integer> list = map.get(entry.getKey());
        Collections.sort(list);
        result = Math.max(result, (list.get(list.size() - 1) - list.get(0)));
    }
    return result;
}

通過上述解決方案，我們可以解決問題，但它不是 O(N) 時間復雜度。 所以我在Java中尋找這個問題的優化解決方案。

Answer 1

// Collections.sort(list);//去掉這一行使得O(NlogK)到O(N)的時間復雜度

  static int solution(int[] A) {
    int N = A.length;
    int result = 0;
    Map<Integer, List<Integer>> map = new HashMap<>();
    for (int i = 0; i < N; i++) {
        List<Integer> list = map.getOrDefault(A[i], new ArrayList<>());
        list.add(i);
        map.put(A[i], list);

    }
    for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
        List<Integer> list = map.get(entry.getKey());
        result = Math.max(result, (list.get(list.size() - 1) - list.get(0)));
    }
    return result;
}

Answer 2

解決方案之一是遍歷所有元素並僅跟蹤第一次和最后一次出現，如下所示：

class Pair<F, S> {
    F first;
    S second;
    constrcutor(F first, S second) {
        this.first = first;
        this.second = second;
    }
}

    static int solution(int arr[]) {

        // Pair.first will contain the first occurrence and Pair.second will contain the last occurrence of number
        HashMap<Integer, Pair<Integer, Integer>> minMaxMap = new HashMap<>();
        for (int index = 0; index < arr.length; index++) {
            Pair<Integer, Integer> existingValue = minMaxMap.get(arr[index]);
            if (existingValue == null) {
                minMaxMap.put(arr[index], new Pair<Integer, Integer>(index, index));
            } else {
                existingValue.second = index; // update the Pair.second to latest value.
            }
        }

        int result = 0;
        for (Pair<Integer, Integer> pair : minMaxMap.values()) {
            int difference = pair.second - pair.first;
            if (difference > result) {
                result = difference;
            }
        }
        return result;
    }

在您的解決方案中，由於我們使用的是列表，因此需要更多 memory 以防數組包含大量重復元素。 通過避免列表，您甚至可以減少 memory 的占用空間。

Answer 3

我認為這看起來是一個有效的解決方案——它不使用任何 collections 並且不需要遍歷所有值。 它檢查最大距離處的對（數組兩端的數字相同），然后是最大距離 - 1 等等，直到找到對為止。

static int solution(int[] A) {
    for (int i = 0; i < A.length; i++) {
        for (int j = 0; j < i; j++) {
            if (A[j] == A[j + A.length - i])
                return A.length - i;
        }
    }
    return -1; //-1 stands for no equal numbers
}