Minimum Absolute Difference Queries

A straightforward approach is to process each query independently. For each query [l, r], we can iterate through the subarray nums[l...r] and find the unique numbers present. Due to the small range of values in nums (1 to 100), we can do this efficiently by checking for the presence of each number in the range [1, 100] within the subarray.

• Initialize an answer array ans.
• For each query [l, r]:
  • Create a boolean array isPresent of size 101, initialized to false.
  • Iterate j from l to r and set isPresent[nums[j]] = true.
  • Find the minimum difference from the isPresent array:
    • Initialize min_diff = Integer.MAX_VALUE and last_present = -1.
    • Iterate k from 1 to 100.
    • If isPresent[k] is true:
      • If last_present was set, update min_diff = Math.min(min_diff, k - last_present).
      • Update last_present = k.
  • If min_diff is still Integer.MAX_VALUE (fewer than 2 unique numbers), the answer is -1. Otherwise, it's min_diff.
  • Store the result in ans.
• Return ans.

This approach handles each query one by one without any global precomputation. For a given query [l, r], we need to find the minimum absolute difference among the unique elements in nums[l...r]. We can leverage the constraint 1 <= nums[i] <= 100. Instead of sorting the subarray (which could be long), we can determine which numbers from 1 to 100 exist in the subarray. We use a boolean array, isPresent of size 101. We iterate through nums[j] for j from l to r and mark isPresent[nums[j]] = true. After identifying all present numbers, we can find the minimum difference by iterating from 1 to 100. We keep track of the last number we saw (last_present) and compute the difference with the current number. If fewer than two unique numbers are found, the answer is -1.

class Solution {
    public int[] minDifference(int[] nums, int[][] queries) {
        int[] ans = new int[queries.length];
        for (int i = 0; i < queries.length; i++) {
            int l = queries[i][0];
            int r = queries[i][1];
            
            boolean[] isPresent = new boolean[101];
            int uniqueCount = 0;
            for (int j = l; j <= r; j++) {
                if (!isPresent[nums[j]]) {
                    isPresent[nums[j]] = true;
                    uniqueCount++;
                }
            }
            
            if (uniqueCount < 2) {
                ans[i] = -1;
                continue;
            }
            
            int minDiff = Integer.MAX_VALUE;
            int lastPresent = -1;
            for (int k = 1; k <= 100; k++) {
                if (isPresent[k]) {
                    if (lastPresent != -1) {
                        minDiff = Math.min(minDiff, k - lastPresent);
                    }
                    lastPresent = k;
                }
            }
            ans[i] = minDiff;
        }
        return ans;
    }
}