Leetcode-Hot100 on GzzhM

[LeetCode][hot100] 图论

Tue, 11 Aug 2026 00:00:00 +0000

200. 岛屿数量

思路 :

使用标记数组标记每一个走过的路地，并且计数。
如果没有走过路地，那么从当前路地节点走一遍bfs 跑完所有路地节点。

#define x first
#define y second
typedef pair<int,int> PII ;

const int N = 310 ;
bool st[N][N];
int cnt ;
PII q[N*2];
int n,m;
void init() {
    memset(st,0,sizeof(st)); 
    cnt = 0 ;
    n = 0 ;
    m = 0 ;
}

int wx[] = {1,-1,0,0} ;
int wy[] = {0,0,1,-1};

void bfs(int sx,int sy,vector<vector<char>>& g) {
    int hh  = 0 , tt = 0 ;
    q[0] = {sx,sy};
    st[sx][sy] = 1 ;
    
    while(hh <= tt) {
        PII t = q[hh ++ ];
            for(int i = 0 ; i < 4 ; i ++ ) {
                int dx = t.x + wx[i];
                int dy = t.y + wy[i];

                if(dx < 0 || dx >= n || dy < 0 || dy >= m ) continue;
                if(g[dx][dy] == '0' || st[dx][dy]) continue ;

                q[++tt] = {dx,dy};
                st[dx][dy] = 1;
            }
        }
}

class Solution {
public:
    int numIslands(vector<vector<char>>& grid) {
        init() ;
         n = grid.size() ;
         m = grid[0].size() ;

        for(int i = 0 ; i < n ; i ++ ) {
            for(int j = 0 ; j < m ; j ++ ) {
                if(grid[i][j] == '1' && !st[i][j]) {
                    bfs(i,j,grid);
                    cnt ++ ;
                }
            }
        }
        return cnt ;
    }
};

994.腐烂的橘子

腐烂的橘子

思路 :

和岛屿数量差不多。无非是让烂橘子进行bfs
计算每个烂橘子到新鲜橘子的最短距离。然后求一个最大值即可

因为 n,m = 10 . 所以直接这样子暴力了

#define x first
#define y second
typedef pair<int,int> PII ;

const int N = 20 ;
const int INF = 0x3f3f3f3f ;

int dist[N][N];
PII q[N*N];
int n,m;

bool st[20][20];
void init() {
    memset(dist,INF,sizeof(dist)); 
    n = 0 ;
    m = 0 ;
}

int wx[] = {1,-1,0,0} ;
int wy[] = {0,0,1,-1};

void bfs(int sx,int sy,vector<vector<int>>& g) {
    memset(st,0,sizeof(st)); 
    int hh  = 0 , tt = 0 ;
    q[0] = {sx,sy};
    dist[sx][sy] = 0 ;
    st[sx][sy] = 1;
    
    while(hh <= tt) {
        PII t = q[hh ++ ];
        for(int i = 0 ; i < 4 ; i ++ ) {
            int dx = t.x + wx[i];
            int dy = t.y + wy[i];
            if(dx < 0 || dx >= n || dy < 0 || dy >= m ) continue;
            if(g[dx][dy] == 0 || g[dx][dy] == 2) continue ;
            if(st[dx][dy]) continue;
            st[dx][dy] = 1; 
            dist[dx][dy] = min(dist[dx][dy], dist[t.x][t.y] + 1);
            q[++tt] = {dx,dy};
        }
    }
}


class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        init(); 
        n = grid.size();
        m = grid[0].size();
    
        for(int i = 0 ; i < n ; i ++ )
            for(int j = 0 ; j < m ; j ++ ) {
                if(grid[i][j] == 2) {
                     bfs(i,j,grid);
                }
        }

        int ans = 0;
        for(int i = 0 ; i < n ; i ++ )
            for(int j = 0 ; j < m ; j ++ ) {
                if(grid[i][j] == 1 ) {
                    if (dist[i][j] == INF)return -1;
                    else ans = max(ans , dist[i][j]);
                }
            }
        return ans ;
    }
};

当然也可以使用多源 bfs 进行优化

class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        int n = grid.size(), m = grid[0].size();
        int wx[4] = {1, -1, 0, 0};
        int wy[4] = {0, 0, 1, -1};

        queue<pair<int, int>> q;
        int fresh = 0;

        // 所有烂橘子同时入队，作为多个源点
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j] == 2) {
                    q.push({i, j});
                } else if (grid[i][j] == 1) {
                    fresh++;
                }
            }
        }

        if (fresh == 0) return 0;

        int minutes = 0;
        while (!q.empty()) {
            int sz = q.size();
            bool infected = false;

            // 同一分钟内，当前层全部扩散完
            for (int i = 0; i < sz; i++) {
                auto [x, y] = q.front();
                q.pop();

                for (int k = 0; k < 4; k++) {
                    int dx = x + wx[k];
                    int dy = y + wy[k];
                    if (dx < 0 || dx >= n || dy < 0 || dy >= m) continue;
                    if (grid[dx][dy] != 1) continue;

                    grid[dx][dy] = 2;   // 标记已腐烂，避免重复入队
                    q.push({dx, dy});
                    fresh--;
                    infected = true;
                }
            }

            if (infected) minutes++;
        }

        return fresh == 0 ? minutes : -1;
    }
};

207. 课程表

课程表

思路 :

主要考察的是拓扑排序

拓扑排序我们的方法是

查找所有入度为0的点进去队列，然后减少其关联的点
然后再重新入所有入度为0的点

const int N = 4e3 + 10 ;

int h[N] , e[N], ne[N], idx;

int d[N] ;

int num ;
 
 
void init(){
    memset(h,-1,sizeof(h));
    memset(e,0,sizeof(e));
    memset(ne,0,sizeof(ne));
    memset(d,0,sizeof(d));
    idx = 0 ;
    num = 0 ;
}

// a -> b 
void add(int a,int b) {
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++ ;
}

bool topsort() {
    int cnt = 0 ;
    queue<int> q;
    for(int i = 0;  i < num ; i ++ ) {
        if(!d[i]) q.push(i);
    }

    while(!q.empty()) {
        int t = q.front() ;
        q.pop () ;
        cnt ++ ;
        for(int i = h[t] ; i!= -1 ; i = ne[i]) {
            int j = e[i] ;
            d[j] -- ;
            if(!d[j]) q.push(j);
        }
    }
    return cnt == num; 
}


class Solution {
public:
    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
        init(); 
        num = numCourses ; 

        for(auto x : prerequisites) {
            int a = x[0];
            int b = x[1];
            add(a,b);
            d[b] ++ ;
        }

        return topsort();
    }
};

208. 实现 Trie (前缀树)

实现 Trie (前缀树)

Tire 的实现思路

定义 son[p][u] ; 表示第 p 层节点是否有值 u
然后再进行顺序即可

class Trie {
static const int N = 4e4 + 10 ;
int son[N][26];
int idx ;
bool isEnd[N];

public:
    Trie() {
        memset(son,0,sizeof(son));
        memset(isEnd,0,sizeof(isEnd));
        idx = 0 ;
    }   
    
    void insert(string word) {
        int p = 0 ;
        for(auto x : word) {
            int u = x-'a';
            if(!son[p][u]) son[p][u] = ++idx; 
            p = son[p][u];
        }
        isEnd[p] = 1; 
    }
    
    bool search(string word) {
        int p = 0 ;
        for(auto x : word) {
            int u = x-'a';
            if(son[p][u]) p = son[p][u];
            else return false;
        }
        return isEnd[p];
    }
    
    bool startsWith(string prefix) {
        int p = 0 ;
        for(auto x : prefix) {
            int u = x-'a';
            if(son[p][u]) p = son[p][u];
            else return false;
        }
        return p ; 
    }
};

/**
 * Your Trie object will be instantiated and called as such:
 * Trie* obj = new Trie();
 * obj->insert(word);
 * bool param_2 = obj->search(word);
 * bool param_3 = obj->startsWith(prefix);
 */

[LeetCode][hot100] 滑动窗口

Fri, 07 Aug 2026 00:00:00 +0000

3. 无重复字符的最长子串

无重复字符的最长子串

#include <bits/stdc++.h>

const int N = 1e5 + 10 ;
int mp[N];

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        memset(mp,0,sizeof(mp));
        int ans =  0 ;
        int n = s.size();

        int j = 0 ;
        for(int i = 0 ; i < n ; i ++ ) {
            mp[s[i]] ++ ;
            while(mp[s[i]] > 1 && j < i)  {
                mp[s[j ++ ]]  -- ; 
            }
            ans =max(ans , i - j   + 1);
        }
        return ans ; 
    }
};

心路历程

说实话挑着滑动窗口做的，但是这道题是一个双指针的题。没什么难度直接就做了。另外 leetcode 这种需要人眼 debug 的模式确实很刺激。

一开始写的是 mp[j] > 1 该成了 mp[s[j]] 后面自测还是不对又改成了 mp[s[i]] 人眼 debug 加缺少深度思考确实很容易写偏

438. 找到字符串中所有字母异位词

找到字符串中所有字母异位词

const int N = 3e4 + 10 ;
int tt , hh ; 
int cnt[27],cnts[27];
int q[N];

void init() {
    tt = - 1;
    hh = 0 ;
    memset(cnt,0,sizeof(cnt));
    memset(cnts,0,sizeof(cnts));
}

bool check() {
    for(int i = 0 ; i < 26 ; i ++ ) {
        if(cnt[i] != cnts[i]) {
            return false; 
        }
    }
    return true ;
}


class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        init();
        int n = s.size();
        int k = p.size();
        vector<int> ans ;
        for(int i  = 0 ; i < k ; i ++ ) {
            cnt[p[i]- 'a'] ++ ;
        }

        for(int i = 0 ; i < n ; i ++ ) {
            q[++tt] = s[i];
            cnts[s[i] - 'a']++;
            // 2. 超过 k 则左端出
            if (tt - hh + 1 > k) {
                cnts[q[hh++] - 'a']--;
            }
            // 3. 长度刚好 k 再判断
            if (tt - hh + 1 == k && check()) {
                ans.push_back(i - k + 1);
            }
        }
        return ans ; 
    }
};

// 固定窗口 len(p)
// 寻找 cnt[p...] = cnt[ans , ans + len(p)]  这里看着是 O(n) 的 
// 找的是异位词 如果是同位词 感觉就像是 KMP里面的next 数组了

// 需要有一个算法能够快速 check cnt , 外面的循环肯定是 On 的
// 我们只 check 26个字母。 那么就是 On * 26 只需要通过滑动窗口固定一下窗口即可，当成为队列的时候 check 一下

心路历程

这道题上来就压力拉满了还以为要我写 kmp next 数组的求法但是想了一下我们可以暴力的使用 cnt 进行遍历

不过一开始写滑动窗口的代码很傻逼

我一开始是这样子处理的,如果队列把当前字符插入到队列里面。如果队列满了那么就判断。

我这里的判读逻辑导致我遗漏了当前满节点的这个值。

后来优化了一下代码成上面的样子之后就完成了

        for(int i = 0 ; i < n ; i ++ ) {
            if(tt < hh || (tt - hh  + 1 < k ))  {
                q[++tt] = s[i]; // 空的话入队列 或者 窗口比较小
                cnts[s[i] - 'a'] ++ ;
            }else { // 队列已经满了
                if(check()) {
                    ans.push_back( i -  k  + 1); 
                }
                cnts[q[hh ++ ] - 'a'] -- ; // 队头弹出队列
            }   
        }

实际可以改成

        for(int i = 0 ; i < n ; i ++ ) {
            if(tt < hh || (tt - hh  + 1 < k ))  {
                q[++tt] = s[i]; // 空的话入队列 或者 窗口比较小
                cnts[s[i] - 'a'] ++ ;
            }else { // 队列已经满了
                if(check()) {
                    ans.push_back( i -  k); 
                }
                cnts[s[i] - 'a'] ++ ;
                q[++tt] = s[i];
                cnts[q[hh ++ ] - 'a'] -- ; // 队头弹出队列
            }   
        }

        if(check()) {
            ans.push_back( n -  k); 
        }

[LeetCode] 300. 最长递增子序列

Wed, 08 Jul 2026 00:00:00 +0000

题目

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。示例 2：

输入：nums = [0,1,0,3,2,3] 输出：4 示例 3：

输入：nums = [7,7,7,7,7,7,7] 输出：1

思路

这道题的数据范围很小，可以考虑暴力，我们很想当然可以想到

f[i] 表示当前以 i 结尾的最长子序列是是多少, 那么答案就是 f[i] = f[j] + 1 (a[j] < a[i] , j ~ (0~i))

这样子的思路是 N^2 的

我们改变思路将 f[i] 表示当前长度为i的最长子序列，结尾最小的数是f[i]

那么对于 a[i] 来说，我们只需要找到第一个能插进去的位置即可，即找到一个比 a[i] 大的最小的数。这样子我们可以优化第二层的时间复杂度为O(logN)

简单拿一组数据来说 101,102,103,104,2 , 当我们遍历到 104 的时候我们发现只能找到 f[4] 说明它可以接到 f[4]后面，即f[5] = a[i]

但是当我们遍历到 2 的时候，发现只能找到F[0] 说明只能找到长度为 1 的序列，那么他只会更新F[1] = a[i]

代码

const int N  = 2e5+10;
int q[N];
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        int len = 0 ;
        for(int i = 0 ;i < n ; i ++ ) {
            int l = 0, r = len ;
            while(l < r) {
                int mid = l+r+1>>1;
                if(q[mid] < nums[i]) l = mid;
                else r = mid - 1;
            }
            len = max(len,r + 1);
            q[r+1] = nums[i];
        }
        return len ;
    }
};

[LeetCode][hot100] 560. 和为 K 的子数组

Tue, 29 Apr 2025 00:00:00 +0000

题目

给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的子数组的个数。子数组是数组中元素的连续非空序列。

示例 1：

输入：nums = [1,1,1], k = 2

输出：2

示例 2：

输入：nums = [1,2,3], k = 3

输出：2

提示：

1 <= nums.length <= 2 * 104

-1000 <= nums[i] <= 1000

-107 <= k <= 107

思路

对于需要找到 X + Y = K 的模型，我们统一想到使用 map[X-K] = Y 的优化，可以将 n^2 -> O(n)
对于这题我们需要把子数组和看为X, 我们计算前缀和 SUM[i] 表示，以 i 结尾前面所有数值的和. 因为我们知道 K 所以我们并不需要去找到我们的 Y, 我们只需要保证，我们能全量的枚举出X 即 SUM[i]
因此我们只需要ans = ans + map[sum[i] - K] 即可

tips :

当我们 sum[1] - K == 2 并且在 sum[3] - K == 2 , 那么我们是否重复计算了 [0~3] 的某些子数组呢 ?

结论是 : 我们 sum[3]-K == 2 的成立是由于引入了A[2] , 因此不存在重复计算

func subarraySum(nums []int, k int) int {
    count := make(map[int]int)
    count[0] = 1
    preSum := 0 
    ans := 0 
    for  _ , v := range nums  {
        preSum += v
        ans += count[preSum - k]
        count[preSum] ++ 
    }
    return ans 
}