前端网络实战手册：15个高频工作场景全解析

掘金前端

作者再学一点就睡Orz

2026年1月15日 23:57

在前端开发中，网络问题是绕不开的坎——真机调试连不上、端口被占、跨域报错、线上打不开... 这些问题看似棘手，实则有固定排查逻辑。本文整理15个高频工作场景，从问题本质到解决方案逐一拆解，附关键命令与

GDAL 创建矢量图层的两种方式

掘金前端

作者 GIS之路

2026年1月15日 21:32

^ 关注我，带你一起学GIS ^ 前言由于本文由一些前置知识，在正式开始之前，需要你掌握一定的Python开发基础和GDAL的基本概念。在之前的文章中讲解了如何使用GDAL或者ogr2ogr工具将t

掘金前端
网页版时钟rocky191
2026年1月15日 20:45

网页版时钟

掘金前端

作者 rocky191

2026年1月15日 20:45

网页版时钟小工具，浏览器全屏显示后，当成屏保，也不错。通过 ai coding 生成，以前可能小半天的事情，现在只需几分钟！

最大化网格图中正方形空洞的面积

LeetCode 每日一题题解

作者 LeetCode-Solution

2026年1月12日 12:41

方法一：排序

思路与算法

题目要求通过移除部分横线段和竖线段，使剩余网格图中的正方形空洞面积最大。可以发现，正方形空洞的边长取决于移除的横向和纵向最大连续线段数目。因此，具体做法如下：

首先对 $\textit{hBars}$ 和 $\textit{vBars}$ 从小到大进行排序，方便后续计算连续线段数目。
分别遍历排序后的数组 $\textit{hBars}$ 和 $\textit{vBars}$，统计横向最大连续线段数目 $\textit{hmax}$ 和纵向最大连续线段数目 $\textit{vmax}$。
计算最大正方形边长 $\textit{side}$ 为 $\min(hmax, vmax) + 1$，返回面积即为边长的平方 $\textit{side}^2$。

代码

###C++

class Solution {
public:
    int maximizeSquareHoleArea(int n, int m, vector<int>& hBars, vector<int>& vBars) {
        sort(hBars.begin(), hBars.end());
        sort(vBars.begin(), vBars.end());
        int hmax = 1, vmax = 1;
        int hcur = 1, vcur = 1;
        for (int i = 1; i < hBars.size(); i++) {
            if (hBars[i] == hBars[i - 1] + 1) {
                hcur++;
            } else {
                hcur = 1;
            }
            hmax = max(hmax, hcur);
        }
        for (int i = 1; i < vBars.size(); i++) {
            if (vBars[i] == vBars[i - 1] + 1) {
                vcur++;
            } else {
                vcur = 1;
            }
            vmax = max(vmax, vcur);
        }
        int side = min(hmax, vmax) + 1;
        return side * side;
    }
};

###Go

func maximizeSquareHoleArea(n int, m int, hBars []int, vBars []int) int {
    sort.Ints(hBars)
    sort.Ints(vBars)
    hmax, vmax := 1, 1
    hcur, vcur := 1, 1
    for i := 1; i < len(hBars); i++ {
        if hBars[i] == hBars[i - 1] + 1 {
            hcur++
        } else {
            hcur = 1
        }
        hmax = max(hmax, hcur)
    }
    for i := 1; i < len(vBars); i++ {
        if vBars[i] == vBars[i - 1] + 1 {
            vcur++
        } else {
            vcur = 1
        }
        vmax = max(vmax, vcur)
    }
    side := min(hmax, vmax) + 1
    return side * side
}

###Python

class Solution:
    def maximizeSquareHoleArea(self, n: int, m: int, hBars: List[int], vBars: List[int]) -> int:
        hBars.sort()
        vBars.sort()
        hmax, vmax = 1, 1
        hcur, vcur = 1, 1
        for i in range(1, len(hBars)):
            if hBars[i] == hBars[i - 1] + 1:
                hcur += 1
            else:
                hcur = 1
            hmax = max(hmax, hcur)
        for i in range(1, len(vBars)):
            if vBars[i] == vBars[i - 1] + 1:
                vcur += 1
            else:
                vcur = 1
            vmax = max(vmax, vcur)
        side = min(hmax, vmax) + 1
        return side * side

###Java

class Solution {
    public int maximizeSquareHoleArea(int n, int m, int[] hBars, int[] vBars) {
        Arrays.sort(hBars);
        Arrays.sort(vBars);
        int hmax = 1, vmax = 1;
        int hcur = 1, vcur = 1;
        for (int i = 1; i < hBars.length; i++) {
            if (hBars[i] == hBars[i - 1] + 1) {
                hcur++;
            } else {
                hcur = 1;
            }
            hmax = Math.max(hmax, hcur);
        }
        for (int i = 1; i < vBars.length; i++) {
            if (vBars[i] == vBars[i - 1] + 1) {
                vcur++;
            } else {
                vcur = 1;
            }
            vmax = Math.max(vmax, vcur);
        }
        int side = Math.min(hmax, vmax) + 1;
        return side * side;
    }
}

###TypeScript

function maximizeSquareHoleArea(n: number, m: number, hBars: number[], vBars: number[]): number {
    hBars.sort((a, b) => a - b);
    vBars.sort((a, b) => a - b);
    let hmax = 1, vmax = 1;
    let hcur = 1, vcur = 1;
    for (let i = 1; i < hBars.length; i++) {
        if (hBars[i] === hBars[i - 1] + 1) {
            hcur++;
        } else {
            hcur = 1;
        }
        hmax = Math.max(hmax, hcur);
    }
    for (let i = 1; i < vBars.length; i++) {
        if (vBars[i] === vBars[i - 1] + 1) {
            vcur++;
        } else {
            vcur = 1;
        }
        vmax = Math.max(vmax, vcur);
    }
    const side = Math.min(hmax, vmax) + 1;
    return side * side;
}

###JavaScript

function maximizeSquareHoleArea(n, m, hBars, vBars) {
    hBars.sort((a, b) => a - b);
    vBars.sort((a, b) => a - b);
    let hmax = 1, vmax = 1;
    let hcur = 1, vcur = 1;
    for (let i = 1; i < hBars.length; i++) {
        if (hBars[i] === hBars[i - 1] + 1) {
            hcur++;
        } else {
            hcur = 1;
        }
        hmax = Math.max(hmax, hcur);
    }
    for (let i = 1; i < vBars.length; i++) {
        if (vBars[i] === vBars[i - 1] + 1) {
            vcur++;
        } else {
            vcur = 1;
        }
        vmax = Math.max(vmax, vcur);
    }
    const side = Math.min(hmax, vmax) + 1;
    return side * side;
}

###C#

public class Solution {
    public int MaximizeSquareHoleArea(int n, int m, int[] hBars, int[] vBars) {
        Array.Sort(hBars);
        Array.Sort(vBars);
        int hmax = 1, vmax = 1;
        int hcur = 1, vcur = 1;
        for (int i = 1; i < hBars.Length; i++) {
            if (hBars[i] == hBars[i - 1] + 1) {
                hcur++;
            } else {
                hcur = 1;
            }
            hmax = Math.Max(hmax, hcur);
        }
        for (int i = 1; i < vBars.Length; i++) {
            if (vBars[i] == vBars[i - 1] + 1) {
                vcur++;
            } else {
                vcur = 1;
            }
            vmax = Math.Max(vmax, vcur);
        }
        int side = Math.Min(hmax, vmax) + 1;
        return side * side;
    }
}

###C

int compare(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

int maximizeSquareHoleArea(int n, int m, int* hBars, int hBarsSize, int* vBars, int vBarsSize) {
    qsort(hBars, hBarsSize, sizeof(int), compare);
    qsort(vBars, vBarsSize, sizeof(int), compare);
    int hmax = 1, vmax = 1;
    int hcur = 1, vcur = 1;
    for (int i = 1; i < hBarsSize; i++) {
        if (hBars[i] == hBars[i - 1] + 1) {
            hcur++;
        } else {
            hcur = 1;
        }
        hmax = fmax(hmax, hcur);
    }
    for (int i = 1; i < vBarsSize; i++) {
        if (vBars[i] == vBars[i - 1] + 1) {
            vcur++;
        } else {
            vcur = 1;
        }
        vmax = fmax(vmax, vcur);
    }
    int side = fmin(hmax, vmax) + 1;
    return side * side;
}

###Rust

use std::cmp;

impl Solution {
    pub fn maximize_square_hole_area(n: i32, m: i32, mut h_bars: Vec<i32>, mut v_bars: Vec<i32>) -> i32 {
        h_bars.sort_unstable();
        v_bars.sort_unstable();
        let mut hmax = 1;
        let mut vmax = 1;
        let mut hcur = 1;
        let mut vcur = 1;
        for i in 1..h_bars.len() {
            if h_bars[i] == h_bars[i - 1] + 1 {
                hcur += 1;
            } else {
                hcur = 1;
            }
            hmax = cmp::max(hmax, hcur);
        }
        for i in 1..v_bars.len() {
            if v_bars[i] == v_bars[i - 1] + 1 {
                vcur += 1;
            } else {
                vcur = 1;
            }
            vmax = cmp::max(vmax, vcur);
        }
        let side = cmp::min(hmax, vmax) + 1;
        side * side
    }
}

复杂度分析

时间复杂度：$O(h \log h + v \log v)$，其中 $h$ 和 $v$ 分别为数组 $\textit{hBars}$ 和 $\textit{vBars}$ 的长度。对 $\textit{hBars}$ 和 $\textit{vBars}$ 排序分别需要 $O(h \log h)$ 和 $O(v \log v)$。
空间复杂度：$O(\log h + \log v)$。对 $\textit{hBars}$ 和 $\textit{vBars}$ 排序分别需要 $O(\log h)$ 和 $O(\log v)$ 的栈空间。