624. Maximum Distance in Arrays

Problem statement

Given m arrays, and each array is sorted in ascending order. Now you can pick up two integers from two different arrays (each array picks one) and calculate the distance. We define the distance between two integers a and b to be their absolute difference |a-b|. Your task is to find the maximum distance.

Example 1:

Input:
[[1,2,3],
 [4,5],
 [1,2,3]]
Output: 4
Explanation:
One way to reach the maximum distance 4 is to pick 1 in the first or third array and pick 5 in the second array.

Note:

1. Each given array will have at least 1 number. There will be at least two non-empty arrays.
2. The total number of the integers in all the m arrays will be in the range of [2, 10000].
3. The integers in the m arrays will be in the range of [-10000, 10000].

Solution

This is the first question in leetcode weekly contest 37, the key issue is we need to find the maximum distance among two different arrays.

My solution:

The general idea is as follows:

1. Two vectors, store all min and max value with their array index in the format of pair.
2. Sort these two vectors.
3. Return values: if min and max values come from different arrays, return their difference directly. Otherwise, do more process.

Time complexity is O(nlgn), space complexity is O(n). n is the number of arrays.

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        vector<pair<int, int>> minv;
        vector<pair<int, int>> maxv;
        // add each value with it`s array index to a vector
        for(int i = ; i < arrays.size(); i++){
            minv.push_back({arrays[i][], i});
            maxv.push_back({arrays[i].back(), i});
        }
        // sort the array by incrasing order
        sort(minv.begin(), minv.end());
        sort(maxv.begin(), maxv.end());
        // return directly if the min and max come from different arrays
        if(minv[].second != maxv.back().second){
            return maxv.back().first - minv[].first;
        } else {
            // otherwise
            return maxv.back().first - minv[].first > maxv[maxv.size() - ].first - minv[].first ?
               maxv.back().first - minv[].first :  maxv[maxv.size() - ].first - minv[].first;
        }
    }
};

The solution from leetcode

This solution is more intuitive and is the most concise version.

Since the max difference of min and max can not come from same array, we store the min and max value in previous processed arrays and compare with current min and max.

Time complexity is O(n), space complexity is O(1).

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        int minv = arrays[][];
        int maxv = arrays[].back();
        int max_dis = INT_MIN;
        for(int i = ; i < arrays.size(); i++){
            max_dis = max(max_dis, max(abs(maxv - arrays[i][]), abs(arrays[i].back() - minv)));
            maxv = max(maxv, arrays[i].back());
            minv = min(minv, arrays[i][]);
        }
        return max_dis;
    }
};