跳转至

624. 数组列表中的最大距离

题目描述

给定 m 个数组，每个数组都已经按照升序排好序了。

现在你需要从两个不同的数组中选择两个整数（每个数组选一个）并且计算它们的距离。两个整数 a 和 b 之间的距离定义为它们差的绝对值 |a-b| 。

返回最大距离。

示例 1：

输入：[[1,2,3],[4,5],[1,2,3]]
输出：4
解释：
一种得到答案 4 的方法是从第一个数组或者第三个数组中选择 1，同时从第二个数组中选择 5 。

示例 2：

输入：arrays = [[1],[1]]
输出：0

 

提示：

  • m == arrays.length
  • 2 <= m <= 105
  • 1 <= arrays[i].length <= 500
  • -104 <= arrays[i][j] <= 104
  • arrays[i] 以 升序 排序。
  • 所有数组中最多有 105 个整数。

 

解法

方法一：维护最大值和最小值

我们注意到，最大距离一定是两个数组中的一个最大值和另一个最小值之间的距离。因此，我们可以维护两个变量，分别表示当前数组中的最大值和最小值，然后遍历数组，更新最大距离，同时更新最大值和最小值。

遍历结束后，即可得到最大距离。

时间复杂度 $O(m)$，空间复杂度 $O(1)$。其中 $m$ 为数组的个数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution:
    def maxDistance(self, arrays: List[List[int]]) -> int:
        ans = 0
        mi, mx = arrays[0][0], arrays[0][-1]
        for arr in arrays[1:]:
            a, b = abs(arr[0] - mx), abs(arr[-1] - mi)
            ans = max(ans, a, b)
            mi = min(mi, arr[0])
            mx = max(mx, arr[-1])
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
class Solution {
    public int maxDistance(List<List<Integer>> arrays) {
        int ans = 0;
        int mi = arrays.get(0).get(0);
        int mx = arrays.get(0).get(arrays.get(0).size() - 1);
        for (int i = 1; i < arrays.size(); ++i) {
            var arr = arrays.get(i);
            int a = Math.abs(arr.get(0) - mx);
            int b = Math.abs(arr.get(arr.size() - 1) - mi);
            ans = Math.max(ans, Math.max(a, b));
            mi = Math.min(mi, arr.get(0));
            mx = Math.max(mx, arr.get(arr.size() - 1));
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        int ans = 0;
        int mi = arrays[0][0], mx = arrays[0][arrays[0].size() - 1];
        for (int i = 1; i < arrays.size(); ++i) {
            auto& arr = arrays[i];
            int a = abs(arr[0] - mx), b = abs(arr[arr.size() - 1] - mi);
            ans = max({ans, a, b});
            mi = min(mi, arr[0]);
            mx = max(mx, arr[arr.size() - 1]);
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func maxDistance(arrays [][]int) (ans int) {
    mi, mx := arrays[0][0], arrays[0][len(arrays[0])-1]
    for _, arr := range arrays[1:] {
        a, b := abs(arr[0]-mx), abs(arr[len(arr)-1]-mi)
        ans = max(ans, max(a, b))
        mi = min(mi, arr[0])
        mx = max(mx, arr[len(arr)-1])
    }
    return ans
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
function maxDistance(arrays: number[][]): number {
    const n = arrays.length;
    let res = 0;
    let [min, max] = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];

    for (let i = 0; i < n; i++) {
        const a = arrays[i];
        res = Math.max(Math.max(a.at(-1)! - min, max - a[0]), res);
        min = Math.min(min, a[0]);
        max = Math.max(max, a.at(-1)!);
    }

    return res;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
/**
 * @param {number[][]} arrays
 * @return {number}
 */
var maxDistance = function (arrays) {
    const n = arrays.length;
    let res = 0;
    let [min, max] = [Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY];

    for (let i = 0; i < n; i++) {
        const a = arrays[i];
        res = Math.max(Math.max(a.at(-1) - min, max - a[0]), res);
        min = Math.min(min, a[0]);
        max = Math.max(max, a.at(-1));
    }

    return res;
};

方法二：一行

1
2
3
4
5
6
7
8
9
const maxDistance = (arrays: number[][]): number =>
    arrays.reduce(
        ([res, min, max], a) => [
            Math.max(Math.max(a.at(-1)! - min, max - a[0]), res),
            Math.min(min, a[0]),
            Math.max(max, a.at(-1)!),
        ],
        [0, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY],
    )[0];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
/**
 * @param {number[][]} arrays
 * @return {number}
 */
var maxDistance = arrays =>
    arrays.reduce(
        ([res, min, max], a) => [
            Math.max(Math.max(a.at(-1) - min, max - a[0]), res),
            Math.min(min, a[0]),
            Math.max(max, a.at(-1)),
        ],
        [0, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY],
    )[0];

评论