给定 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 个整数。

 

题意：选择两个不同的数组 $A$ 和 $B$，然后从 $A$ 中选一个数 $x$，$B$ 中选一个数 $y$，最大化 $|x-y|$。

如果固定 $A$ 和 $B$，那么 $|x-y|$ 最大是多少？

• 如果 $x\ge y$，那么 $|x-y|=x-y$。贪心地想，$x$ 越大越好，$y$ 越小越好。所以 $x$ 应该取 $\max(A)$，$y$ 应该取 $\min(B)$。
• 如果 $x< y$，那么 $|x-y|=y-x$。贪心地想，$x$ 越小越好，$y$ 越大越好。所以 $x$ 应该取 $\min(A)$，$y$ 应该取 $\max(B)$。

所以我们只需考虑每个数组的最小值和最大值。由于题目保证数组是升序的，所以数组第一个数就是最小值，最后一个数就是最大值。

既然要选两个数组，我们可以枚举 $A=\textit{arrays}[i]$ 作为右边那个数组，然后维护左边所选数组的第一个数的最小值 $\textit{mn}$ 和最后一个数的最大值 $\textit{mx}$。

数组 $A$ 和左边的数组各选一个数，能形成的最大差值为

$$
\max(|A[n-1]-\textit{mn}|, |\textit{mx} - A[0]|)
$$

其中 $n$ 为 $A$ 的长度。用上式更新答案的最大值。

实际上，不需要算绝对值，只需要计算

$$
\max(A[n-1]-\textit{mn}, \textit{mx} - A[0])
$$

如果出现 $A[n-1]-\textit{mn} < 0$，也就是 $A[n-1] < \textit{mn}$ 的情况，那么有

$$
A[0] \le A[n-1] < \textit{mn} \le \textit{mx}
$$

所以有 $\textit{mx} - A[0]\ge \textit{mn} - A[n-1] = |A[n-1]-\textit{mn}| > 0$。我们既不需要算绝对值，又保证了 $\textit{mx} - A[0]$ 比 $|A[n-1]-\textit{mn}|$ 更大。

对于 $\textit{mx} - A[0] < 0$ 的情况同理。

⚠注意：代码实现时，要先更新答案，再更新 $\textit{mn}$ 和 $\textit{mx}$。如果反过来，可能出现同一个数组选两个数的情况，不符合题目要求。

###py

class Solution:
    def maxDistance(self, arrays: List[List[int]]) -> int:
        ans = 0
        mn, mx = inf, -inf
        for a in arrays:
            ans = max(ans, a[-1] - mn, mx - a[0])
            mn = min(mn, a[0])
            mx = max(mx, a[-1])
        return ans

###java

class Solution {
    public int maxDistance(List<List<Integer>> arrays) {
        int ans = 0;
        int mn = Integer.MAX_VALUE / 2; // 防止减法溢出
        int mx = Integer.MIN_VALUE / 2;
        for (List<Integer> a : arrays) {
            int x = a.get(0);
            int y = a.get(a.size() - 1);
            ans = Math.max(ans, Math.max(y - mn, mx - x));
            mn = Math.min(mn, x);
            mx = Math.max(mx, y);
        }
        return ans;
    }
}

###cpp

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        int ans = 0;
        int mn = INT_MAX / 2, mx = INT_MIN / 2; // 防止减法溢出
        for (auto& a : arrays) {
            ans = max({ans, a.back() - mn, mx - a[0]});
            mn = min(mn, a[0]);
            mx = max(mx, a.back());
        }
        return ans;
    }
};

###c

#define MIN(a, b) ((b) < (a) ? (b) : (a))
#define MAX(a, b) ((b) > (a) ? (b) : (a))

int maxDistance(int** arrays, int arraysSize, int* arraysColSize) {
    int ans = 0;
    int mn = INT_MAX / 2, mx = INT_MIN / 2; // 防止减法溢出
    for (int i = 0; i < arraysSize; i++) {
        int x = arrays[i][0], y = arrays[i][arraysColSize[i] - 1];
        ans = MAX(ans, MAX(y - mn, mx - x));
        mn = MIN(mn, x);
        mx = MAX(mx, y);
    }
    return ans;
}

###go

func maxDistance(arrays [][]int) (ans int) {
    mn, mx := math.MaxInt/2, math.MinInt/2 // 防止减法溢出
    for _, a := range arrays {
        x, y := a[0], a[len(a)-1]
        ans = max(ans, y-mn, mx-x)
        mn = min(mn, x)
        mx = max(mx, y)
    }
    return
}

###js

var maxDistance = function(arrays) {
    let ans = 0;
    let mn = Infinity, mx = -Infinity;
    for (const a of arrays) {
        ans = Math.max(ans, a[a.length - 1] - mn, mx - a[0]);
        mn = Math.min(mn, a[0]);
        mx = Math.max(mx, a[a.length - 1]);
    }
    return ans;
};

###rust

impl Solution {
    pub fn max_distance(arrays: Vec<Vec<i32>>) -> i32 {
        let mut ans = 0;
        let mut mn = i32::MAX / 2; // 防止减法溢出
        let mut mx = i32::MIN / 2;
        for a in arrays {
            let x = a[0];
            let y = a[a.len() - 1];
            ans = ans.max(y - mn).max(mx - x);
            mn = mn.min(x);
            mx = mx.max(y);
        }
        ans
    }
}

复杂度分析

• 时间复杂度：$\mathcal{O}(m)$，其中 $m$ 是 $\textit{arrays}$ 的长度。
• 空间复杂度：$\mathcal{O}(1)$。

更多相似题目，见下面数据结构题单中的「§0.1 枚举右，维护左」。

分类题单

如何科学刷题？

1. 滑动窗口与双指针（定长/不定长/单序列/双序列/三指针/分组循环）
2. 二分算法（二分答案/最小化最大值/最大化最小值/第K小）
3. 单调栈（基础/矩形面积/贡献法/最小字典序）
4. 网格图（DFS/BFS/综合应用）
5. 位运算（基础/性质/拆位/试填/恒等式/思维）
6. 图论算法（DFS/BFS/拓扑排序/最短路/最小生成树/二分图/基环树/欧拉路径）
7. 动态规划（入门/背包/状态机/划分/区间/状压/数位/数据结构优化/树形/博弈/概率期望）
8. 【本题相关】常用数据结构（前缀和/差分/栈/队列/堆/字典树/并查集/树状数组/线段树）
9. 数学算法（数论/组合/概率期望/博弈/计算几何/随机算法）
10. 贪心与思维（基本贪心策略/反悔/区间/字典序/数学/思维/脑筋急转弯/构造）
11. 链表、二叉树与回溯（前后指针/快慢指针/DFS/BFS/直径/LCA/一般树）
12. 字符串（KMP/Z函数/Manacher/字符串哈希/AC自动机/后缀数组/子序列自动机）

我的题解精选（已分类）

欢迎关注 B站@灵茶山艾府

[TOC]

解决方案

---

方法 1 暴力解法（超时）

简单的解决办法是从每个数组 $arrays$ 中的每一个元素开始，计算它与除了自身之外的其他所有数组的每一个元素的距离，并找出其中的最大距离。

###Java

class Solution {
    public int maxDistance(List<List<Integer>> arrays) {
        int res = 0;
        int n = arrays.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < arrays.get(i).size(); j++) {
                for (int k = i + 1; k < n; k++) {
                    for (int l = 0; l < arrays.get(k).size(); l++) {
                        res = Math.max(res, Math.abs(arrays.get(i).get(j) - arrays.get(k).get(l)));
                    }
                }
            }
        }
        return res;
    }
}

###C#

public class Solution {
    public int MaxDistance(IList<IList<int>> arrays) {
        int res = 0;
        int n = arrays.Count;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < arrays[i].Count; j++) {
                for (int k = i + 1; k < n; k++) {
                    for (int l = 0; l < arrays[k].Count; l++) {
                        res = Math.Max(res, Math.Abs(arrays[i][j] - arrays[k][l]));
                    }
                }
            }
        }
        return res;
    }
}

###C++

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        int res = 0;
        int n = arrays.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < arrays[i].size(); j++) {
                for (int k = i + 1; k < n; k++) {
                    for (int l = 0; l < arrays[k].size(); l++) {
                        res = max(res, abs(arrays[i][j] - arrays[k][l]));
                    }
                }
            }
        }
        return res;
    }
};

###Go

func maxDistance(arrays [][]int) int {
    res := 0
    n := len(arrays)
    for i := 0; i < n - 1; i++ {
        for j := 0; j < len(arrays[i]); j++ {
            for k := i + 1; k < n; k++ {
                for l := 0; l < len(arrays[k]); l++ {
                    res = max(res, abs(arrays[i][j] - arrays[k][l]))
                }
            }
        }
    }
    return res
}

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

###Python

class Solution:
    def maxDistance(self, arrays: List[List[int]]) -> int:
        res = 0
        n = len(arrays)
        for i in range(n - 1):
            for j in range(len(arrays[i])):
                for k in range(i + 1, n):
                    for l in range(len(arrays[k])):
                        res = max(res, abs(arrays[i][j] - arrays[k][l]))
        return res

###C

int maxDistance(int** arrays, int arraysSize, int* arraysColSize) {
    int res = 0;
    for (int i = 0; i < arraysSize - 1; i++) {
        for (int j = 0; j < arraysColSize[i]; j++) {
            for (int k = i + 1; k < arraysSize; k++) {
                for (int l = 0; l < arraysColSize[k]; l++) {
                    int diff = abs(arrays[i][j] - arrays[k][l]);
                    if (diff > res) {
                        res = diff;
                    }
                }
            }
        }
    }
    return res;
}

###JavaScript

var maxDistance = function(arrays) {
    let res = 0;
    let n = arrays.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = 0; j < arrays[i].length; j++) {
            for (let k = i + 1; k < n; k++) {
                for (let l = 0; l < arrays[k].length; l++) {
                    res = Math.max(res, Math.abs(arrays[i][j] - arrays[k][l]));
                }
            }
        }
    }
    return res;
};

###TypeScript

function maxDistance(arrays: number[][]): number {
    let res = 0;
    let n = arrays.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = 0; j < arrays[i].length; j++) {
            for (let k = i + 1; k < n; k++) {
                for (let l = 0; l < arrays[k].length; l++) {
                    res = Math.max(res, Math.abs(arrays[i][j] - arrays[k][l]));
                }
            }
        }
    }
    return res;
};

###Rust

impl Solution {
    pub fn max_distance(arrays: Vec<Vec<i32>>) -> i32 {
        let mut res = 0;
        let n = arrays.len();
        for i in 0..n - 1 {
            for &x in &arrays[i] {
                for k in i + 1..n {
                    for &y in &arrays[k] {
                        res = res.max((x - y).abs());
                    }
                }
            }
        }
        res
    }
}

复杂度分析

• 时间复杂度: $O((n*x)^2)$。我们对于每一个数组的元素，都会遍历完 $arrays$ 中的所有数组。这里，$n$ 指的是 $arrays$ 中的数组的数量，$x$ 指的是 $arrays$ 中的每个数组的平均元素个数。
• 空间复杂度: $O(1)$。只使用了常数级的额外空间。

---

方法 2 更好的暴力解法（超时）

算法
在上一个方法 中，我们没有利用到每个数组在 $arrays$ 中都被排序过的事实。因此，我们不需要考虑所有数组(除了数组内部的元素)之间所有元素的距离，我们只需要考虑数组中的第一个(最小元素)和其它数组中最后一个(最大元素)之间的距离，然后从这些距离中找出最大距离。

###Java

class Solution {
    public int maxDistance(List<List<Integer>> arrays) {
        List<Integer> array1, array2;
        int res = 0;
        int n = arrays.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                array1 = arrays.get(i);
                array2 = arrays.get(j);
                res = Math.max(res, Math.abs(array1.get(0) - array2.get(array2.size() - 1)));
                res = Math.max(res, Math.abs(array2.get(0) - array1.get(array1.size() - 1)));
            }
        }
        return res;
    }
}

###C#

public class Solution {
    public int MaxDistance(IList<IList<int>> arrays) {
        IList<int> array1, array2;
        int res = 0;
        int n = arrays.Count;
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                array1 = arrays[i];
                array2 = arrays[j];
                res = Math.Max(res, Math.Abs(array1[0] - array2[array2.Count - 1]));
                res = Math.Max(res, Math.Abs(array2[0] - array1[array1.Count - 1]));
            }
        }
        return res;
    }
}

###C++

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        vector<int> array1, array2;
        int res = 0;
        int n = arrays.size();
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                array1 = arrays[i];
                array2 = arrays[j];
                res = max(res, abs(array1[0] - array2[array2.size() - 1]));
                res = max(res, abs(array2[0] - array1[array1.size() - 1]));
            }
        }
        return res;
    }
};

###Go

func maxDistance(arrays [][]int) int {
    var array1, array2 []int
    res := 0
    n := len(arrays)
    for i := 0; i < n-1; i++ {
        for j := i + 1; j < n; j++ {
            array1 = arrays[i]
            array2 = arrays[j]
            res = max(res, abs(array1[0] - array2[len(array2) - 1]))
            res = max(res, abs(array2[0] - array1[len(array1) - 1]))
        }
    }
    return res
}

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

###Python

class Solution:
    def maxDistance(self, arrays: List[List[int]]) -> int:
        res = 0
        n = len(arrays)
        for i in range(n - 1):
            for j in range(i + 1, n):
                array1 = arrays[i]
                array2 = arrays[j]
                res = max(res, abs(array1[0] - array2[-1]))
                res = max(res, abs(array2[0] - array1[-1]))
        return res

###C

int maxDistance(int** arrays, int arraysSize, int* arraysColSize) {
    int res = 0;
    for (int i = 0; i < arraysSize - 1; i++) {
        for (int j = i + 1; j < arraysSize; j++) {
            int* array1 = arrays[i];
            int* array2 = arrays[j];
            res = fmax(res, abs(array1[0] - array2[arraysColSize[j] - 1]));
            res = fmax(res, abs(array2[0] - array1[arraysColSize[i] - 1]));
        }
    }
    return res;
}

###JavaScript

var maxDistance = function(arrays) {
    let res = 0;
    let n = arrays.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = i + 1; j < n; j++) {
            let array1 = arrays[i];
            let array2 = arrays[j];
            res = Math.max(res, Math.abs(array1[0] - array2[array2.length - 1]));
            res = Math.max(res, Math.abs(array2[0] - array1[array1.length - 1]));
        }
    }
    return res;
};

###TypeScript

function maxDistance(arrays: number[][]): number {
    let res = 0;
    let n = arrays.length;
    for (let i = 0; i < n - 1; i++) {
        for (let j = i + 1; j < n; j++) {
            let array1 = arrays[i];
            let array2 = arrays[j];
            res = Math.max(res, Math.abs(array1[0] - array2[array2.length - 1]));
            res = Math.max(res, Math.abs(array2[0] - array1[array1.length - 1]));
        }
    }
    return res;
};

###Rust

impl Solution {
    pub fn max_distance(arrays: Vec<Vec<i32>>) -> i32 {
        let mut res = 0;
        let n = arrays.len();
        for i in 0..n - 1 {
            for j in i + 1..n {
                let array1 = &arrays[i];
                let array2 = &arrays[j];
                res = res.max((array1[0] - array2[array2.len() - 1]).abs());
                res = res.max((array2[0] - array1[array1.len() - 1]).abs());
            }
        }
        res
    }
}

复杂度分析

• 时间复杂度: $O(n^2)$. 我们只考虑每个数组的最大和最小值。这里，$n$ 指的是 $arrays$ 中的数组的数量。
• 空间复杂度: $O(1)$. 只使用了常数级的额外空间。

---

方法 3 单次扫描

算法
如已经讨论过的，为了找出任何两个数组之间的最大距离，我们不需要比较数组中的每一个元素，因为数组已经被排序过了。因此，我们只需要考虑数组中的极值来计算距离。
此外，被考虑用于计算距离的两个点不应该都属于同一个数组。因此，对于当前选择的数组 $a$ 和 $b$，我们只需要找出 $a[n-1]-b[0]$ 和 $b[m-1]-a[0]$ 中的较大者来找出较大的距离。这里，$n$ 和 $m$ 分别指的是数组 $a$ 和 $b$ 的长度。
但是，我们不需要比较所有可能的数组对来找出最大距离。相反，我们可以不断地遍历 $arrays$ 中的数组，并跟踪到目前为止发现的最大距离。
为此，我们需要跟踪到目前为止找到的最小值（$min_val$）和最大值（$max_val$）。因此，现在这些极值可以被视为代表到目前为止考虑过的所有数组的累积数组的极点。
对于每一个新考虑的数组，我们找到 $a[n-1]-min_val$ 和 $max_val - a[0]$ 与到目前为止找到的最大距离进行对比。这里的$n$指的是当前数组 a 的元素数量。此外，我们需要注意，到目前为止找到的最大距离并不总是由距离的端点 $max_val$和$min_val$ 贡献。
但是，这些类型的点可能在未来有助于最大化距离。因此，我们需要跟踪这些最大值和最小值以及到目前为止找到的最大距离进行未来的计算。但是，一般来说，最终找到的最大距离总是由这些极值，$max_val$和$min_val$， 或在某些情况下，由它们两者决定的。
下面的动画示例了这个过程。

<{:width=400},{:width=400},{:width=400},{:width=400},{:width=400},{:width=400},{:width=400},{:width=400}>

从上述插图中，我们可以清楚地看到，尽管 $max_val$ 或 $min_val$ 可能不能为局部最大距离值做出贡献，但是他们稍后可以做出最大距离的贡献。

###Java

class Solution {
    public int maxDistance(List<List<Integer>> arrays) {
        int res = 0;
        int n = arrays.get(0).size();
        int min_val = arrays.get(0).get(0);
        int max_val = arrays.get(0).get(arrays.get(0).size() - 1);
        for (int i = 1; i < arrays.size(); i++) {
            n = arrays.get(i).size();
            res = Math.max(res, Math.max(Math.abs(arrays.get(i).get(n - 1) - min_val), 
                                         Math.abs(max_val - arrays.get(i).get(0))));
            min_val = Math.min(min_val, arrays.get(i).get(0));
            max_val = Math.max(max_val, arrays.get(i).get(n - 1));
        }
        return res;
    }
}

###C#

public class Solution {
    public int MaxDistance(IList<IList<int>> arrays) {
        int res = 0;
        int n = arrays[0].Count;
        int minVal = arrays[0][0];
        int maxVal = arrays[0][arrays[0].Count - 1];
        for (int i = 1; i < arrays.Count; i++) {
            n = arrays[i].Count;
            res = Math.Max(res, Math.Max(Math.Abs(arrays[i][n - 1] - minVal), 
                                         Math.Abs(maxVal - arrays[i][0])));
            minVal = Math.Min(minVal, arrays[i][0]);
            maxVal = Math.Max(maxVal, arrays[i][n - 1]);
        }
        return res;
    }
}

###C++

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        int res = 0;
        int n = arrays[0].size();
        int min_val = arrays[0][0];
        int max_val = arrays[0][arrays[0].size() - 1];
        for (int i = 1; i < arrays.size(); i++) {
            n = arrays[i].size();
            res = max(res, max(abs(arrays[i][n - 1] - min_val), 
                               abs(max_val - arrays[i][0])));
            min_val = min(min_val, arrays[i][0]);
            max_val = max(max_val, arrays[i][n - 1]);
        }
        return res;
    }
};

###Go

func maxDistance(arrays [][]int) int {
    res := 0
    n := len(arrays[0])
    minVal := arrays[0][0]
    maxVal := arrays[0][n - 1]
    for i := 1; i < len(arrays); i++ {
        n = len(arrays[i])
        res = max(res, max(abs(arrays[i][n-1] - minVal),
                           abs(maxVal - arrays[i][0])))
        minVal = min(minVal, arrays[i][0])
        maxVal = max(maxVal, arrays[i][n-1])
    }
    return res
}

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

###Python

class Solution:
    def maxDistance(self, arrays: List[List[int]]) -> int:
        res = 0
        n = len(arrays[0])
        min_val = arrays[0][0]
        max_val = arrays[0][-1]
        
        for i in range(1, len(arrays)):
            n = len(arrays[i])
            res = max(res, max(abs(arrays[i][n - 1] - min_val), 
                            abs(max_val - arrays[i][0])))
            min_val = min(min_val, arrays[i][0])
            max_val = max(max_val, arrays[i][-1])
        
        return res

###C

int maxDistance(int** arrays, int arraysSize, int* arraysColSize) {
    int res = 0;
    int n = arraysColSize[0];
    int min_val = arrays[0][0];
    int max_val = arrays[0][arraysColSize[0] - 1];
    for (int i = 1; i < arraysSize; i++) {
        n = arraysColSize[i];
        res = fmax(res, fmax(abs(arrays[i][n - 1] - min_val), 
                             abs(max_val - arrays[i][0])));
        min_val = fmin(min_val, arrays[i][0]);
        max_val = fmax(max_val, arrays[i][n - 1]);
    }
    
    return res;
}

###JavaScript

var maxDistance = function(arrays) {
    let res = 0;
    let n = arrays[0].length;
    let minVal = arrays[0][0];
    let maxVal = arrays[0][n - 1];
    for (let i = 1; i < arrays.length; i++) {
        n = arrays[i].length;
        res = Math.max(res, Math.max(Math.abs(arrays[i][n - 1] - minVal), 
                                     Math.abs(maxVal - arrays[i][0])));
        minVal = Math.min(minVal, arrays[i][0]);
        maxVal = Math.max(maxVal, arrays[i][n - 1]);
    }
    return res;
};

###TypeScript

function maxDistance(arrays: number[][]): number {
    let res = 0;
    let n = arrays[0].length;
    let minVal = arrays[0][0];
    let maxVal = arrays[0][n - 1];
    
    for (let i = 1; i < arrays.length; i++) {
        n = arrays[i].length;
        res = Math.max(res, Math.max(Math.abs(arrays[i][n - 1] - minVal), 
                                     Math.abs(maxVal - arrays[i][0])));
        minVal = Math.min(minVal, arrays[i][0]);
        maxVal = Math.max(maxVal, arrays[i][n - 1]);
    }
    return res;
};

###Rust

impl Solution {
    pub fn max_distance(arrays: Vec<Vec<i32>>) -> i32 {
        let mut res = 0;
        let mut min_val = arrays[0][0];
        let mut max_val = arrays[0][arrays[0].len() - 1];
        for i in 1..arrays.len() {
            let n = arrays[i].len();
            res = res.max((arrays[i][n - 1] - min_val).abs());
            res = res.max((max_val - arrays[i][0]).abs());
            min_val = min_val.min(arrays[i][0]);
            max_val = max_val.max(arrays[i][n - 1]);
        }
        res
    }
}

复杂度分析

• 时间复杂度: $O(n)$. 我们只遍历了一次长度为 $n$ 的 $arrays$。
• 空间复杂度: $O(1)$. 只使用了常数级的额外空间。

容易出错的地方：

可能最大最小的都在一个vector里面

思路：

1.保存当前最大和最小
2.遍历，当前vector的最大和最小和之前保存的比较，更新距离
3.更新最大和最小，继续遍历

代码：

class Solution {
public:
    int maxDistance(vector<vector<int>>& arrays) {
        int dist = 0;
        int max = arrays[0].back();
        int min = arrays[0].front();
        for (int i = 1; i < arrays.size(); i++) {
            dist = std::max(dist, std::max(arrays[i].back() - min, max - arrays[i].front()));
            max = std::max(arrays[i].back(), max);
            min = std::min(arrays[i].front(), min);
        }
        return dist;
    }
};

前端解决请求竞态问题 前端请求竞态问题是指，当多个异步请求（例如 AJAX 请求）几乎同时发出，但它们的响应顺序不确定时，可能会导致 UI 显示错误或数据不一致。 这种情况通常发生在用户快速连续触发多

以下是一些前端面试题： 一、HTML/CSS部分 请描述HTML的语义化标签的重要性，并列举一些常用的语义化标签。 答案： 重要性： 对搜索引擎优化（SEO）有帮助，搜索引擎能够更好地理解页面结构，从

死亡笔记： 声明式记录器采用"登记制"（直接存储标识符） 对象式记录器采用"租赁制"（动态访问对象属性） with语句已被废弃（性能黑洞，严格模式禁用） 1.2 变量解析：作用域链的死亡爬梯 灵魂拷问

概要 鸿蒙开发设置应用名称与图标。 最终的效果： 修改名称 在项目中目录中：src/main/module.json5 label设置 $string:EntryAbility_label 修改src

目录 执行上下文类型 全局执行上下文 函数执行上下文 Eval 执行上下文 变量环境 vs 词法环境 变量环境（Variable Environment） 词法环境

引言 背景：这段时间开发了一个全栈项目，以新闻管理这个业务为切入点，锻炼自己开发后端服务、以及前端各平台应用、还有部署相关的能力。项目包含了一个nodejs服务、新闻管理后台前端项目、新闻阅读web端

栈结构 栈（Stack）是一种常见的数据结构，遵循 后进先出（LIFO, Last In First Out） 的原则。最后入栈的元素最先出栈。 队列结构 队列（Queue）是一种常见的数据结构，遵循

学习Web3是一个涉及区块链、智能合约、去中心化应用（DApps）等多个领域的复杂过程。以下是一个详细的学习路径图，帮助你逐步掌握Web3的核心概念和技能： 1. 基础知识 1.1 区块链基础 区块链

在使用 @monaco-editor/react 会报一个 editor 可能为 null的错 在其他项目并不会，查看 yarn.lock 发现多了个其他项目没有的依赖 重新yarn了就没有了 另外这

介绍 React Hooks 的基本原理，重点分析了React 内置 Hooks（如 useState、useEffect、useRef）如何利用闭包管理组件的状态和副作用，确保数据在组件内持久化。

在 Vue.js 中，provide 和 inject 是一种用于跨层级组件通信的机制，允许父组件向深层嵌套的子组件传递数据，而不需要通过 props 逐层传递。

Vue3 的 Composition API 和 Options API 有哪些区别？举例说明 Composition API 的优势。 Composition API 允许将逻辑更加集中和复用如数据

以下是一些实用的 CSS 小技巧及示例，附浏览器兼容性说明，帮助开发者提升效率并处理常见问题。哈哈哈

今天心血来潮，想用一下volta，于是按照官方文档安装一下了，发现竟然没让我设置安装路径，直接给我安装了c盘了，属实是让我难受啊，毕竟大多数软件都惦记着c盘空间。要是只是安装在c盘也没啥，毕竟volt

2025 年了，我不允许有前端不会用 Trae 让页面 Hero Section 变得高级！！！(Threejs) HeroSection 专栏再度来袭！！！