算法 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); 
        }

[Acwing] 基础算法(十一) 欧拉函数

Thu, 16 Jul 2026 00:00:00 +0000

欧拉函数

什么是欧拉函数

对于一个数 N, phi(N) = x 其中 x 代表 1~n 中与n 互质的个数

互质的意思就是 n 与 a 没有公因子

算法思路

我们知道一个数 n = p1^a1 * p2^a2 ... pn^an

即对于 p1 有 x1 个数在 1~n中不是互质的因为他是因子，那么不互质的个数就是 y1 = n - n/p1 算个倍数

同理可得其他质因子的算法从而推出 phi = n * (1 - 1/p1) * (1- 1/p2)... (1-1/pn)

代码

int phi(int x) {
  int res = x ;
  for(int i = 2; i <= x/ i ; i ++ ) {
      
    if(x % i == 0 ) {
      res = res - res/i;
      while(x % i == 0 ) x/=i ; 
    }
  }
if(x > 1) res = res  - res / x ;
  return res; 
}

时间复杂度

sqrtN

[Acwing] 基础算法(十) 约数

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

约数

约数的概念 : 能被整除的数叫做约数即 d|n ,d是 n 的约数

试除法求约数

算法思路

我们在 试除法求质数 的时候，知道如果d|n那么d/n | n 因为一个数的约数最小都是 2倍

所以我们可以通过 for(int i = 2; i <= x/i ; i ++ ) 的方式寻找约数

不过需要注意的是对于 1 可以是任何数的约数

所以我们这里的循环需要从 1 开始取

代码


vector<int> getDiv(int x){ 
    vector<int> ans ;
    for(int i = 1; i <= x/ i ; i ++ ) {
        if(x % i == 0) {
            ans.push_back(i);
            if(i != x /i ) {
                ans.push_back(x/i);
            }
        }
    }
    sort(ans.begin(),ans.end());
    return ans ;
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cin>>n;
  while(n -- ) {
    int x;cin>>x;
    auto ans = getDiv(x);
    for(auto res : ans) {
        cout<<res<<" ";
    }
    cout<<endl;
  }
  return 0;
}

时间复杂度

O sqrtN

约数个数

算法思路

我们知道一个数可以拆分成 n = p1^a1*p2^a2*p3^a3...pn^an 这是质因数分解的章节学到的

同时我们可以知道对于 p1 的幂，取值有 0~a1 种，因为剩下的p2...pn可以被整除

所以根据排列我们知道约数个数为 (a1+1)*(a2+1) ... (an+1)

代码

  int n;
    cin>>n;

    unordered_map<int,int> primes;//映射函数

    while(n--)
    {
        int x;
        scanf("%d",&x);

        for(int i=2;i<=x/i;i++)
        while(x%i==0)
        {
            primes[i]++;
            x/=i;//方便求得约数的数量
        }

        if(x>1) primes[x]++;//x的最大公约数可能大于sqrt(x);
    }

    long long res=1;
    for(auto p:primes) res=res*(p.second+1)%mod;//将统计出来的数按照由图中公式所得出来的结论得出答案

    printf("%lld\n",res);

时间复杂度

o sqrtN

约数之和

算法思路

题目求的是所有约数乘积的和

即 (p0^a1 + p1^a2 .... pn^an+1) * (p?1^b1 + p?2^b2 ... p?n^bn)

根据乘法原理我们可以提取出来

(p0^0 + .. p0 ^(a1 + ???) ) * (pk^0 + ...) 的形式

因此我们只需要做一次质因数分解，然后根据次数进行求质数幂次的乘积和即可

代码

#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int N = 1e6+10, mod = 1e9+7;
int n;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  cin>>n;
  unordered_map<int,int> mp ;
  while(n -- ) {
    int x;cin>>x;
    for(int i = 2; i <= x / i; i++) {
        while(x % i == 0) {
            x /= i;
            mp[i]++;
        }
    }
    if(x > 1) mp[x]++;
  }
  LL ans  = 1;
  for(auto x : mp) {
    LL t = 1; 
    int a = x.second ; 
    while(a -- ) {
        t = (t * x.first + 1) % mod ;
    }
    ans = ans%mod * t %mod ;
    
  }
  cout<<ans<<endl;
  return 0;
}

时间复杂度

o sqrtN

最大公约数

算法思路

我们知道如果 x | a 并且 x | b 那么 x | a * y + b * k

同理对于 gcd(a,b) = gcd(b, a % b) 为什么等式成立？因为 x | b 那么 x | a + c * b 这里的 c 就是 -a/b

因为 x | a + c *b - c*b 等式成立所以 x|a成立

代码

1
2
3

int gcd(int a,int b) {
  return b ? gcd(b , a %b) : a; 
}

时间复杂度

[Acwing] 基础算法(九) 质数

Tue, 14 Jul 2026 00:00:00 +0000

质数

质数的概念

对于大于 1 的数，其因数只有他自己和1 那么这个数就是质数

试除法判定质数

算法思路

根据质数的定义出发我们可以很简单的想到下面的形式，进行枚举来判断出来是否是质数

  for(int i = ; i <= n ; i ++ ) {
        if(n%i == 0) {
            return false ;
        }
  }

但是这种算法是 on 的

我们根据 d | n 那么 d/n | n 可以得到 d < n^2

这个怎么理解，例如 2 | 8 那么 4 | 8 因为最小的质数是 2 因此肯定存在这种情况

所以我们可以考虑优化 i 的枚举, 从而达到 sqrt(n) 的时间复杂度

  for(int i = ; i <= n/ i ; i ++ ) {
        if(n%i == 0) {
            return false ;
        }
  }

时间复杂度

分解质因数

算法思路

我们需要知道对于一个数 n 他可以拆成多个质数p幂的乘积即 n = p1^a1 * p2^a2.. pn^an

我们需要分解质因数，只需要从小到大枚举出能够整除的数即可,因为我们肯定会先遇到2，3这个质数，除完之后发现剩下的数也都是质数

代码

void SplitPrime(int x) {
    for(int i = 2 ;i <=  x / i ; i ++ ) {
        if(n % i == 0 ) {
            int s = 0 ;
            while(x % i == 0 ) {
                x /= i ;
                s ++ ;
            }
            cout<<i<<" "<<s<<endl;
        }
    }
    if(x > 1) {
        cout<<x<<" "<<1<<endl;
    }
}

时间复杂度

logn ~ sqrt(n) 之间

筛质数

埃及筛

算法思路

我们知道一个质数 i ，他的倍数 2*i,n*i 的因数肯定是 i

所以我们可以根据这个性质过滤掉 i 的倍数

代码

void filterPrime() {
    int cnt = 0 ;
    for(int i  = 2; i <=  n ; i ++ ) {
        if(!st[i]) {
            for(int j = i ; j <= n ; j += i  ) st[j] = 1;
            cnt ++ ;
         }
    }
    cout<<cnt<<endl;
}

时间复杂度

o (nlnln)

线性筛

线性筛是对埃及筛的一个优化，我们每次都用 最小质因子进行优化

代码

void filterPrime() {
    int cnt = 0 ;
    for(int i = 2; i <= n; i ++ )  {
        if(!st[i]) prime[++cnt] = i ;
        for(int j = 1 ; prime[j] <= n / i  ; j ++ ) {
            st[prime[j] * i] = 1 ;
            if(i % prime[j] == 0) break; 
        }
    }
    cout<<cnt<<endl;
}

时间复杂度

[Acwing] 基础算法(八) 堆

Mon, 13 Jul 2026 00:00:00 +0000

Heap

算法思路

我们使用一维数组来表示一个堆,堆的性质是一个完全二叉树，其中根是最小值，左右节点均小于父节点

我们使用 x表示根节点，则 2*x表示左节点 , 2*x+1 表示右节点

考虑

插入一个数
删除最小值
求最小值

对于插入一个数 :

因为是使用一维数组进行存储的，所以插入的数会在末尾，我们需要考虑进行 up 操作，将其和其父节点进行比较，如果比父节点小那么交换

void up(int u ) {
    while(u/2 && h[u/2] > h[u]) {
        heap_swap(u/2,u);
        u /= 2 ;
    }
}

对于删除最小值

因为最小值在 h[1] 所以考虑删除的时候，应该交换h[size] ，然后size-- 最后将 size 进行一次down操作

down操作也是很简单就能想到是和 左右节点进行比较 ,如果比左右节点大那么进行交换

代码

int n,m;
int h[N],sz ;

void down(int x) {
    int t = x;
    if(x * 2 <= sz && h[t] > h[x * 2]) t = x * 2;
    if(x * 2 + 1 <= sz && h[t] > h[x*2 + 1] ) t = x*2+ 1;
    if(h[x] != h[t]) {
        swap(h[x],h[t]);
        down(t);
    }
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  cin>>n>>m;
  for(int i = 1; i <= n ; i ++ ) cin>>h[i];
  sz = n ;
  for(int i = n/2; i ; i -- ) down(i);
  while(m -- ) {
    cout<<h[sz]<<" ";
    h[1] = h[sz];
    sz -- ;
    down(1);
  }
  return 0;
}

时间复杂度分析

建树的时候是 o(n) 的遍历树的时候是 ologn

模拟堆

在普通堆的基础上增加了

删除第 k 个数
修改第 k 个数

对于删除第 k 个数

我们需要考虑存储 , 第k个数对应在 heap中的下标是什么即 ph[k]
同时因为涉及到交换，我们需要在 o(1) 的时间复杂度知道堆下标i = 2*x? 2*x+1 上堆元素，是第几次插入的 hp

因为如果不知道 hp 元素

我们在交换的时候会遇到

原来：第 m 次插入在位置 a  →  ph[m] = a
      第 n 次插入在位置 b  →  ph[n] = b

交换后：第 m 次插入到了 b  →  ph[m] = b
        第 n 次插入到了 a  →  ph[n] = a

这种奇异的问题，原本第m次插入的a 变成了第n次插入的

除非我们进行 oN 的处理

// 没有 hp 时，每次 swap 都要扫一遍
for (int k = 1; k <= m; k++)
    if (ph[k] == a) ph[k] = b;
    else if (ph[k] == b) ph[k] = a;

但是我们如果引入了 hp 后只需要进行更换即可

void heap_swap(int a, int b)
{
    swap(ph[hp[a]], ph[hp[b]]);  // ph[hp[a]]=a, ph[hp[b]]=b → 交换后变成 b 和 a
    swap(hp[a], hp[b]);
    swap(h[a], h[b]);
}

代码


int n,m;
int h[N],sz , hp[N], ph[N];

void heap_swap(int a,int b)  {
    swap(h[a],h[b]);
    swap(ph[hp[a]], ph[hp[b]]);
    swap(hp[a],hp[b]);
}

void down(int x) {
    int t = x;
    if(x * 2 <= sz && h[t] > h[x * 2]) t = x * 2;
    if(x * 2 + 1 <= sz && h[t] > h[x*2 + 1] + 1) t = x*2+ 1;
    if(x != t) {
       heap_swap(x,t);
    }
    down(t);
}

void up(int u ) {
    while(u/2 && h[u/2] > h[u]) {
        heap_swap(u/2,u);
        u /= 2 ;
    }
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n;cin>>n;
  while(n -- ) {
    string op;cin>>op;
    if(op == "I") {
        int x;cin>>x;
        h[++sz] = x ;
        m ++ ;

        ph[m] = sz ;
        hp[sz] = m ;

        up(sz);
    }else if(op == "PM") {
        cout<<h[1]<<endl;
    }else if(op == "DM") {
        heap_swap(1,sz);
        sz -- ;
        down(1);
    }else if(op == "D") {
        int k;cin>>k;
        k = ph[k];
        heap_swap(k,sz);
        sz -- ;
        up(k);
        down(k);
    }else {
        int k,x;cin>>k>>x;
        k = ph[k];
        h[k] = x;
        up(k);
        down(k);
    }
  }
  return 0;
}

一些感想

好难，说实话涉及到一些指针的来回跳动就完全不会了

[Acwing] 基础算法(七) Tire 树

Sun, 12 Jul 2026 00:00:00 +0000

Tire

算法思路

解决问题 :

解决单词统计类型的问题，或者是说有多少 prefix 是以当前字符串为前缀的串

算法思路：

由于这种题目出现会控制单词长度，所以我们考虑开一个 [N][26] 树用于存储

对于一个单词，相当于一个单边树
对于 abc ,abcd 树会在 c 处进行分叉
每个节点单独赋值 idx
对于访问一个字符串我们可以从根节点开始访问，对于其子串可以使用 p = tire[p][u] 的形式进行递归访问

代码展示


int son[N][26], n, idx ; 
int cnt[N];
char str[N];

void insert(char str[]) {
    int p = 0 ;
    for(int i = 0 ; str[i] ; i ++ ) {
        int u = str[i] - 'a';
        if(!son[p][u]) son[p][u] = ++idx ; 
        p = son[p][u];
    }
    cnt[p] ++ ;
}

int query(char str[]) {
    int p = 0 ;
    for(int i = 0 ; str[i] ; i ++ ) {
        int u = str[i] - 'a';
        if(!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

int main() {
  cin>>n ;
  while(n -- ) {
    char op[2];
    scanf("%s%s", op, str);
    if (*op == 'I') insert(str);
    else cout<<query(str)<<endl;
  }
}

[Acwing] 基础算法（七) 并查集

Sun, 12 Jul 2026 00:00:00 +0000

并查集

算法思路

使用场景

将两个集合进行合并
询问两个元素是否在一个集合中

我们很简单的可以想到判断两个元素是否在一个集合中可以使用map进行 o1 的判断，但是对于合并集合无法避免是 o(n) 的

因此我们考虑使用树的形式存储集合

对于一个集合，其根节点代表整个集合编号
使用 p[x] 表示其父节点

对于一个单边集合

`1`	`1 → 2 → 3 → 4`

我们如果要找到 1 的集合，那么需要从 p[1],p[2],p[3]一直寻找

但是我们可以考虑进行优化，对于找到根节点的集合，我们将其全部转移到根节点，即路径压缩

1
2
3

1 ──┐
2 ──┼──→ 4
3 ──┘

代码

其中 p[x] = find(p[x]) 代表路径压缩

int p[N] ;

int find(int x) {
    if(p[x]!= x) {
        return p[x] = find(p[x]);
    }
    return p[x];
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int n,m;cin>>n>>m;
  for(int  i = 1 ; i <= n ; i ++ ) {
     p[i] = i ;
  }
  for(int i = 1 ; i <= m ; i ++ ) {
    char op;cin>>op ;
    int a,b;cin>>a>>b;
    int fa = find(a);
    int fb = find(b);
    if(op == 'M') {
        p[fa] = fb;
    }else if(op == 'Q') {
        if (fa == fb) {
            cout<<"Yes"<<endl;
        }else {
            cout<<"No"<<endl;
        }
    }
  }
}

[Acwing] 基础算法(六) 数据结构栈&队列

Sat, 11 Jul 2026 00:00:00 +0000

栈

算法思路

我们使用 stk[N],tt 表示栈数组和栈顶指针

对于插入操作 stk[++tt] = x 即可

对于查询是否为空的操作判断 tt != 0 即可

对于删除操作 tt-- 即可

比较简单的一个模拟

待会中午约了散伙饭先收拾去了~

代码

bool checkEmpty() {
    return (tt == 0); 
}

void push(int x) {
    stk[++tt] = x; 
}

int pop() {
    int x = stk[tt];
    tt -- ;
    return x; 
}

int query() {
    return stk[tt];
}

int main() {
    int m; cin>>m ;
    while(m -- ) {
        string op;cin>>op;
        if(op == "push") {
            int x;cin>>x;
            push(x);
        }else if (op == "pop")  {
            pop();
        }else if(op == "empty") {
            if (checkEmpty()) {
                cout<<"YES"<<endl;
            }else {
                cout<<"NO"<<endl;
            }
        }else if(op == "query") {
            cout<<query()<<endl;
        }
    }
    return 0;
}

队列

算法思路

我们通过 hh,tt 表示队头和队尾, 维护一段连续区间

对于弹出操作，我们使用 hh++

对于插入操作, 我们使用 q[++tt]=x

对于查询是否为空的操作，我们使用 hh<=tt

代码

int q[N];

int tt,hh;

void init() {
    tt = -1;
}

bool empty() {
    return (hh <= tt);
}

void add(int x) {
    q[++tt] = x;
}

void pop() {
    hh ++ ;
}

int query() {
    return q[hh];
}


int main() {
    init();
    int m;cin>>m;
    while(m -- ) {
        string op;cin>>op;
        if(op == "push") {
            int x;cin>>x;
            add(x);
        }else if(op == "pop"){
            pop();
        }else if(op == "empty") {
            if(empty()) {
                cout<<"NO"<<endl;
            }else {
                cout<<"YES"<<endl;
            }
        }else if(op == "query") {
            cout<<query()<<endl;
        }
    }
    return 0;
}

单调栈

算法思路

顾名思义，我们维护的是一个 单调递增 or 单调递减 的一个内容

一般情况下我们会考虑一种提醒题型,即找到 当前数左边比自己小的数是什么

那么我们可以考虑维护一个 maxValue 是当前数的栈,对于大于自己的数都出栈，从而保证整个栈的值是递增的

代码

int main() {
    cin>>n;
    for(int i = 1; i <= n ;i ++ ) {
        int x;cin>>x;
        while(tt&&stk[tt] >= x) {
            tt -- ;
        }
        if(!tt) {
            cout<<-1<<" ";
        }else {
            cout<<stk[tt]<<" ";
        }
        stk[++tt] = x;
    }
    return 0;
}

时间复杂度分析

对于我们想要解决这个问题，暴力做法是 n^2 的

但是如果我们对于 a3>a5 的话，我们会发现我们永远用不到 a3 所以我们并不需要单独去遍历他，在最坏情况下也是 2n 的

单调队列

算法思路

同样以 滑动窗口举例 ,我们需要快速的求出一个固定窗口的最大最小值

我们对于 [1 3 -1 -3 5 3 6 7] 这个窗口,在[3,-1,-3] 窗口大小为 3 的时候，我们可以发现，其实-3是最小值，其中3,-1都没有用，因为后面的序列也用不到

所以我们可以维护一个最小值的窗口

考虑

当队头超出窗口那么移出队头
当队内元素大于当前数，那么移除当前元素。因为我们维护的是一个从小到大的序列，所以这里从队尾开始删除
然后把当前数插入进去
并且窗口有输出的时候进行输出

代码

int main() {
    cin>>n>>k;
    int hh = 0 ,tt = -1;
    for(int i = 1 ; i <= n ; i ++ ) cin>>a[i];
    for(int i = 1; i <= n ; i ++ ) {
        if(hh <= tt && i - k  >= q[hh]) hh ++ ;
        while(hh <= tt && a[q[tt]] >= a[i]) tt -- ; // 5 6 2
        q[++tt] = i ;
        if(i-k >= 0) cout<<a[q[hh]]<<" "; 
    }
    hh = 0, tt = -1;
    cout<<endl;

    for(int i = 1; i <= n ; i ++ ) {
        if(hh <= tt && i - k  >= q[hh]) hh ++ ;
        while(hh <= tt && a[q[tt]] <= a[i]) tt -- ; // 5 6 2
        q[++tt] = i ;
        if(i-k >= 0) cout<<a[q[hh]]<<" "; 
    }
}

[Acwing] 基础算法（五) 数据结构链表

Fri, 10 Jul 2026 00:00:00 +0000

链表

单链表

算法思路

我们使用

head 存储头节点

e[i] 存储下标 i 节点的值

ne[i] 表示 i 的后继节点在哪

idx 表示当前点位

对于插入头部的操作

e[idx] = x, ne[idx] = head, head = idx++;

中间插入的操作

e[idx] = x, ne[idx] = ne[k], ne[k] = idx++;

删除的操作

ne[k] = ne[ne[k]];

下面是一个演示过程 :

头插入

1
2
3

H 1:  e[0]=1, ne[0]=-1, head=0        → 链表: 1
H 2:  e[1]=2, ne[1]=0,  head=1        → 链表: 2 → 1
H 3:  e[2]=3, ne[2]=1,  head=2        → 链表: 3 → 2 → 1

调用 Insert 3 5 在第三个数后面插入5

1
2
3

e[3] = 5
ne[3] = ne[2] = 1    // 新节点先接上原来的后继
ne[2] = 3            // 节点 2 改指向新节点

调用 Insert 4 4

1
2
3

e[3] = 5
ne[3] = ne[2] = 1    // 新节点先接上原来的后继
ne[2] = 3            // 节点 2 改指向新节点

最终情况

逻辑链表:  head
              ↓
         ┌────┐    ┌────┐    ┌────┐    ┌────┐    ┌────┐
         │ 3  │ →  │ 5  │ →  │ 4  │ →  │ 2  │ →  │ 1  │ → NULL
         └────┘    └────┘    └────┘    └────┘    └────┘
         下标2     下标3     下标4     下标1     下标0

数组状态:
  i:    0    1    2    3    4
 e[i]:  1    2    3    5    4
ne[i]: -1    0    3    4    1
              ↑    ↑    ↑
              │    │    └─ head=2
              │    └─ ne[2]=3 指向节点5
              └─ ne[4]=1 指向节点2

完整代码

#include <bits/stdc++.h>
#define LL long long
using namespace std;
const int N = 1e5+10;
 
int head, e[N], ne[N], idx ;

void init() {
    head = -1 ;
    idx = 0 ;
}


void add_to_head(int x) {
    e[idx] = x;
    ne[idx] = head ;
    head = idx ++ ;
}

void add(int k ,int x) {
    e[idx] = x ;
    ne[idx] = ne[k];
    ne[k] = idx ++ ; 
}
// 1 , ne[0] = -1
// 2 , ne[1] = 0
// 3 , ne[2] = 1

// 5 , ne[4] = ne[3-1] = 1 ; 3, 1 (ne[3] = 5)

// 4 , ne[3] = 2


void remove(int k) {
    ne[k] = ne[ne[k]];
}

int main() {
    int n;cin>>n;
    init();
    for(int i = 1 ; i<= n ; i ++ ) {
        char op ;cin >> op ;
        if (op == 'H') {
            int x;cin>>x;
            add_to_head(x);
        }else if (op == 'D') {
            int x;cin>>x;
            if (!x) head = ne[head]; 
            else remove(x-1);
        }else if (op == 'I') {
            int k,x;cin>>k>>x;
            add(k-1,x);
        }
    }

    for(int i = head ; i != -1 ; i = ne[i]) {
        cout<<e[i]<<" ";
    }

    return 0;
}

双链表

算法思路

我们假设 [0] [1] 代表我们的左右端点

初始化的时候 r[0] = 1 , l[1] = 0, idx = 2

对于插入操作

我们需要给当前节点赋值
并且使得当前节点的左右指针指向上下两个数
- l[idx] = k, r[idx] = r[k]
同时修改两个被影响的指针
- l[r[k]] = idx, r[k] = idx

这是插入右端点的思路，插入左端点可以认为是在前一个节点插入右端点即inser(l[k],x)

对于删除操作,我们需要把当前节点的上一个节点和下一个节点互相建立关系

将当前节点的左节点的右节点指向下一个节点
- r[l[k]] = r[k]
将当前节点的右节点的左节点指向上一个节点
- l[r[k]] = l[k]

另外需要注意的是，我们一开始就使用了两个节点所以对于操作的节点我们应该认为是 k+1

代码


int e[N],l[N],r[N],idx; 

void init() {
    r[0] = 1, l[1] = 0 ;
    idx = 2;
}

void add(int k,int x) {
    e[idx] = x;

    l[idx] = k ,r[idx] = r[k];

    l[r[k]] = idx, r[k] = idx;
    idx ++ ; 
}

void remove(int k) {
    l[r[k]] = l[k];
    r[l[k]] = r[k];
}

int main() {
    init() ;
    int n;cin>>n;
    for(int i = 1 ; i<= n ;i ++ ) {
        string op;cin>>op;
        if(op == "L") {
            int x;cin>>x;
            add(0,x);
        }else if(op == "R") {
            int x;cin>>x;
            add(l[1], x);
        }else if(op == "D") {
            int k;cin>>k;
            remove(k + 1);
        }else if(op == "IL") {
            int k,x;cin>>k>>x;
            add(l[k+1], x);
        }else {
            int k,x;cin>>k>>x;
            add(k+1,x);
        }
    }
    for(int i = r[0] ; i!= 1; i = r[i]) cout<<e[i]<<" ";
    return 0;
}

[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 ;
    }
};

[Acwing] 基础算法（四) 离散化&区间合并

Thu, 02 Jul 2026 00:00:00 +0000

离散化

整数离散化

算法思路

算法解决的问题是

值域很大, 但是实际操作区域很小的题目

例如 :

在 1e9 的区间范围上操作 3e5 次操作然后进行求和

整个思路如下

先将需要操作的数和查询的数放到一个队列里面
给队列排序去重
通过二分获取每个值应该存在的下标

核心代码展示

    typedef pair<int,int> PII ;
    const int N = 3e5 + 10 ;
    int n , m ;
    int a[N],s[N];

    vector<int> alls ;
    vector<PII> add,query ;
        
    int find(int x) {
        int l = 0 , r = alls.size() - 1;
        while(l < r) {
        int mid = (l + r) >> 1;
            if(alls[mid] >= x) r = mid ;
            else l = mid + 1;
        }
        return r + 1 ;
    }
        cin>>n>>m;
    for(int  i = 1; i <= n ; i ++ ) {
        int x,c; cin >>x>>c;
        add.push_back({x,c});
        alls.push_back(x);
    }
    
    for(int i = 1 ; i <= m ; i ++ ) {
        int l,r;cin>>l>>r;
        query.push_back({l,r});
        alls.push_back({l});
        alls.push_back({r});
    }

    sort(alls.begin(), alls.end());
    alls.erase(unique(alls.begin(), alls.end()), alls.end());
    
    for(auto item : add) {
        int x = find(item.first);
        a[x] += item.second;
    }
    
    for (int i = 1; i <= alls.size(); i ++ )  s[i] = s[i-1] + a[i];
    
    for(auto item : query) {
        int l = find(item.first) ;
        int r = find(item.second) ;
        cout<<s[r] - s[l-1]<<endl;
    }

时间复杂度分析

需要遍历数组 On

感悟

这次学到了一下新玩意

typedef 可以定义 pair

以及 sort 可以直接对数组进行排序

vector.erase(unique(), vector.end()) 可以去重

typedef pair<int,int> PII ;
sort(alls.begin(), alls.end());
alls.erase(unique(alls.begin(), alls.end()), alls.end());
```c++

[Acwing] 基础算法(三) 前缀和&差分

Thu, 25 Jun 2026 00:00:00 +0000

前缀和

一维前缀和

算法思路

使用 Sum 数组累加计算数值数组的和

sum[i] = sum[i-1] + a[i]

从而可以很快的求出某个区间的和，例如

sum[l~r] = sum[r] - sum[l-1]

核心代码展示

    for(int i = 1; i <= n ; i ++ ) cin>>a[i];
    for(int i = 1; i <= n ; i ++) s[i] = s[i-1] + a[i];
    while(m -- ) {
        int l , r ;  cin >> l >> r;
        cout<<s[r] - s[l-1]<<endl;
    }

时间复杂度分析

在只有一次区间询问的时候和 for 循环直接计算无异都是o(n)

但是在多次区间询问的时候可以提前把和计算出来从而使得 o(n*m) 变成 o(n+m)

感悟

小学数学

二维前缀和

算法思路

通过数学方法将 Sxy 代表二维空间中矩形的面积，从而根据二维关系进行处理
不过需要注意的是我们在处理一个区域的面积大时候，需要保证角落上的点也被计算所以就需要 S[x1][y2-1] 以及 s[x2-1][y1] 这种处理

由于作图的时候只有点线，并没有画出具体的面，所以导致写代码的时候很少联想到

核心代码展示

    for(int i = 1; i <= n; i ++ ) 
        for(int j = 1; j <= m ; j ++ ) {
            cin>>a[i][j];
            s[i][j] = a[i][j] + s[i-1][j] + s[i][j-1] - s[i-1][j-1];
        }
    
    while(q -- ) {
        int x1,y1,x2,y2 ;
        cin >> x1>>y1>>x2>>y2;
        cout<< s[x2][y2] - s[x2][y1-1]  - s[x1-1][y2] + s[x1-1][y1-1]<<endl;
    }

时间复杂度分析

o(n*m)

感悟

不用死记公式，根据二维图像脑中进行想象

差分

一维差分

算法思路

使用 Sum 数组累加计算数值数组的和

sum[i] = sum[i-1] + a[i]

从而可以很快的求出某个区间的和，例如

sum[l~r] = sum[r] - sum[l-1]

核心代码展示

    for(int i = 1; i <= n ; i ++ ) cin>>a[i];
    for(int i = 1; i <= n ; i ++) s[i] = s[i-1] + a[i];
    while(m -- ) {
        int l , r ;  cin >> l >> r;
        cout<<s[r] - s[l-1]<<endl;
    }

时间复杂度分析

在只有一次区间询问的时候和 for 循环直接计算无异都是o(n)

但是在多次区间询问的时候可以提前把和计算出来从而使得 o(n*m) 变成 o(n+m)

感悟

小学数学

二维前缀和

算法思路

构造数组 b[i]=a[i]-a[i-1] 是的 Sum[b[]] = a[i]

如果我们需要对一个区间进行一次操作，如 计算区间 [l,r] +c 之后的总和，我们很自然的可以想到 s[r]-s[l-1] + (r-l+1)*c

但是如果我们需要对不同的区间进行多次操作,我们就没办法这样

基于 sum[b[]] = a[i] 的性质，我们对 b[l]+c 并且对 b[r+1]-c 我们得到的数组就是

b[l]=a[l]-a[l-1]+c, b[l+1] = a[l+1]-a[l], .... b[r+1] = a[r+1] - a[r] - a[r]

如果计算前缀和的话会变成

a[l] + ... a[r] + (r-l+1)*c

核心代码展示

void insert(int l,int r,int c) {
    b[l]  += c ;
    b[r+1] -= c;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
    cin>>n>>m;
    for(int i = 1; i <= n; i ++ ) cin >> a[i];
    for(int i = 1 ; i <= n ; i++) insert(i,i,a[i]);
    while(m -- ) {
        int l, r, c; cin>>l>>r>>c;
        insert(l,r,c);
    }
    for(int i = 1; i <= n ; i ++ ) b[i] += b[i-1];
    for(int i = 1; i <= n; i ++ ) cout<<b[i]<<" ";
    return 0;
}

时间复杂度分析

差分时间复杂度 O(1)

感悟

这里说实话就有点抽象了，不实际想想或者是推导很难理解这部分代码

二维差分

算法思路

我们在已知一维差分的操作会因为前缀和的原因导致操作值累加在区间上

在不推导差分数组的前提下 :

我们可以直观的想想如果我们在 x1,y1增加 c 那么剩下的范围都会被影响，即取一个差集

所以我们如果需要给 x1,y1 ,x2,y2 增加 c 的话我们应该

x1,y1 +c,x1,y2+1 -c, x2+1,y1 -c , x2+1,y2+1 +c

从而使得我们的矩形能够加 c

反过来如果我们给 x1,y1,x1,y1 这个区间增加 c 那么最终我们得到的就是原始的数组

核心代码展示

void insert(int x1,int y1,int x2,int y2,int c) {
    b[x1][y1] += c;
    b[x2+1][y1] -= c;
    b[x1][y2+1] -= c;
    b[x2+1][y2+1] += c;
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
    
    cin>>n>>m>>q;
    for(int i = 1; i <= n ; i ++ )
        for(int j = 1 ; j <= m ; j ++ ){
            int c ;cin>>c;
            insert(i,j,i,j,c);
        }
    
    while(q -- ) {
        int x1,x2,y1,y2; cin>>x1>>y1>>x2>>y2;
        int c ; cin>>c;
        insert(x1,y1,x2,y2,c);
    }
    
    for(int i = 1; i <= n ; i ++ )
        for(int j = 1; j <= m ; j ++ )
        b[i][j] += ( b[i-1][j] + b[i][j-1] - b[i-1][j-1]);
    for(int i = 1; i<= n ; i ++ ) {
        for(int j = 1; j <= m ;j ++ ){
        cout<<b[i][j]<<" ";
         }
         cout<<endl;
    }
        
    return 0;
}

时间复杂度分析

O n*m

感悟

二维差分说实话一开始没反应过来，我听y总讲的时候，感觉怎么跳的这么快，连构造数组都不出，原来这里反向思考了一下

而且对于 (x2 + 1) 我刚开始以为 x 是列，问了 gemini 后才知道是行

[Acwing] 基础算法(二) 二分

Tue, 23 Jun 2026 00:00:00 +0000

二分排序

整数二分

算法思路

比较玄学的一句话目前还没懂

二分不一定单调，但是单调一定二分

算法思路

对于一个区间可以拆分成左边不满足条件右边满足条件的数据，可以求满足或者是不满足的数据的边界

对于边界的的定义有 左边界 和 右边界

整体抽象思路如下

设定 mid
check(mid) 如果 mid 符合右区间/左区间
那么答案一定在右区间/左区间, 将 l/r 指针移动到 mid

对于答案在右区间来说，那么需要把 l 移动到 mid 因为 mid 也可能是答案，否则到话 r=mid-1

同样答案在左区间来说，那么需要把 r 移动到 mid 否则到话 l=mid+1

需要注意的是因为程序下取整的原因，需要保证在移动 l=mid 的时候 mid =l+r+1>>1

核心代码展示

        while(l < r) {
            int mid = l+r>>1;
            if(a[mid] >= x) r = mid ;
            else l = mid + 1; 
        }
        if(a[l] != x) {
            cout<<"-1 -1"<<endl;
        }else {
            cout<<l-1<<" ";
            l = 1,  r= n ;
            while(l < r) {
                int mid = l+r+1>>1;
                if(a[mid] <= x) l = mid;
                else r = mid - 1; 
            }
            cout<<r-1<<endl;
        }

时间复杂度分析

每次操作都将区间一分为二，最多logn次求解

感悟

左区间调动右指针，右区间调动左指针有点反直觉但是实际理解下来还好

这个是我下班的时候看的，一开始没想明白，回家锻炼之后然后今天突发的想要跑步，跑了个5公里回来继续看写下的

[Acwing] 基础算法(一) 排序

Wed, 17 Jun 2026 00:00:00 +0000

方法

课上: 学习 主要思想

课下:

理解代码,背过代码
根据题目默写代码 ( 3 ~ 5 次 )

快速排序

算法思路

寻找区间内的随机一个值, 将其当作中间值
遍历当前区间, 将区间分为 [l ~ x] [x ~l] 的形式
递归处理区间, 将大区间拆分成多个小区间进行排序

核心代码展示

void quick_sort(int q[], int l, int r) {
    if (l >= r) return;
    int i = l - 1, j = r + 1, x = q[(l + r) >> 1];
    while (i < j) {
        do i++; while (q[i] < x);
        do j--; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j);
    quick_sort(q, j + 1, r);
}

时间复杂度分析

由于区间是对半拆分的最多只有 logN 层

但是每层都需要进行一次 while(i<j) 的遍历每层需要 o(n) 的时间复杂度

所以总时间复杂度是 o nlogn

最坏情况下 :

例子 A：已有序 + 基准取 q[l]

数组：[1, 2, 3, 4, 5]，每次 pivot = 最左边：

第1次: [1 | 2,3,4,5]     左 1 个，右 4 个
第2次:      [2 | 3,4,5]  右 4 个继续
第3次:           [3 | 4,5]
...

分区大小每次都是 n, n-1, n-2, …, 1 总工作量 n + (n-1) + (n-2) + … + 1 = n(n+1)/2 = O(n²)

理想情况

        n
      /   \
    n/2   n/2
   /  \   /  \
 n/4 ...        高度 ≈ log n，每层总工作量 n

最坏情况

n
 \
  n-1
   \
    n-2
     \
      ...    链状，高度 n，总工作量 n+(n-1)+... = O(n²)

犯错

一开始因为不喜欢 do while 的形式，所以自己单独写了一个 while 的形式

后续发现一直 TLE 后面看了一下在两个相同数的时候，如果先进行判断然后再进行位移指针会卡住程序的运行

初始: i=1, j=2

第 1 轮:
  左扫: 67 < 67 ? 否 → i 停在 1
  右扫: 67 > 67 ? 否 → j 停在 2
  swap(67, 67) → 数组不变

第 2 轮:
  i 还是 1, j 还是 2  → 完全一样 → 永远循环

初始: i=0, j=3

第 1 轮:
  do i++ → i=1, q[1]<67? 否
  do j-- → j=2, q[2]>67? 否
  swap(67,67) → 数组不变

第 2 轮:
  do i++ → i=2   ← 强制从 1 走到 2
  do j-- → j=1   ← 强制从 2 走到 1
  现在 i=2, j=1 → i<j 为假 → 退出

递归 (1,1) 和 (2,2) → 结束

void quick_sort(int q[], int l , int  r) {
	if( l >= r ) {
		return ;
	}
	int x = q[l] ,  i = l , j = r ;
	while(i < j) {
		while(q[i] < x) i ++ ;
		while(q[j] > x)j -- ;
		if(i < j) {
			swap(q[i], q[j]); 
		}
	}
	quick_sort(q, l , j );
	quick_sort(q, j + 1, r);
	return ;
}

感悟

记录一下在上班的时候能够听满 30 分钟的课程之前可是想都不敢想的

第二次默写

第二次默写失败了好多次

signal: bus error 这个错误指的是程序访问了不合法的内存地址因为我代码总累加写错了

变成了 j++

void quick_sort(int q[],int l , int r) {
// ... 
do j ++ ; while(q[j] > x) ;

swap(q[i],q[j]);

}

// ...

}

第二个点就是需要保证 i < j 才能够进行 swap 不然会把原来已经排序好的程序重新打乱
边界的选取

在竞技编程中，为了防错，大家通常死记硬背以下两套固定组合，千万不要交叉使用：

组合一（最常用，推荐）：向下取整配 j

基准值：x = q[(l + r) >> 1];

划分线：j

递归：quick_sort(q, l, j); 和 quick_sort(q, j + 1, r);

组合二：向上取整配 i - 1

基准值：x = q[(l + r + 1) >> 1];

划分线：i - 1

递归：quick_sort(q, l, i - 1); 和 quick_sort(q, i, r);

归并排序

算法思路

递归处理大区间一分为2为小区间
双指针合并两个小区间，保证数组有序

核心代码展示

void merge_sort(int q[], int l, int r) {
	if(l >= r) return ;
	int mid = (l + r) >> 1; 
	merge_sort(q,l,mid) , merge_sort(q,mid + 1, r) ;
	
	int k = 0 , i = l , j = mid + 1;  

	while(i <= mid && j <= r) {
		if(q[i] <= q[j]) temp[++k] = q[i ++ ] ;
		else temp[++k] = q[j ++ ];
	}
	while(i <= mid) temp[++k] = q[i ++ ];
	while(j <= r) temp[++k] = q[j ++] ;
	
	for(int i = l , j = 1 ;  i <= r ; i ++ , j ++ ) q[i] = temp[j];
}

时间复杂度分析

递归处理最多拆分成 logN 个区间，每个区间最多进行 N 次

最坏情况下都排序也是 nlogn 的

感悟

归并排序的过程很好理解，但是实际写代码下来指针很多 i,j,k,mid ，然后还加上递归回溯的处理，导致整个过程比较难理解

[Hdu] 数学基础 day2

Sun, 25 May 2025 00:00:00 +0000

快速幂

求 A^B 的最后三位数表示的整数

输入格式

输入数据包含多个测试实例
每个实例占一行，由两个正整数A和B组成（1 ≤ A,B ≤ 10000）
如果A=0且B=0，则表示输入结束，不做处理

输出格式

对于每个测试实例，输出A^B的最后三位表示的整数
每个输出占一行

输入输出示例

输入样例	输出样例
2 3	8
12 6	984
6789 10000	1
0 0	(无输出)

算法讲解 :

对于 123^(234). 我们可以优化成 (123^2)^117, 再进一步优化成 ((123^2) * 123 )^116
同理往下, 我们可以发现, 我们的计算量由次幂来控制, 同时我们可以根据就性质来操作次幂的优化 3. 对于奇数我们只需要拆成 ans = ans * a 的形式 4. 对于偶数我们只需要拆成 a = a * a 的形式

#include <bits/stdc++.h>
using namespace std;
int qmi(int a, int b) {
    int ans = 1 ; 
    while(b != 0) {
        if(b&1) ans = ans * a % 1000 ; 
        a = a  * a % 1000 ; 
        b = b >> 1; 
    }
    return ans % 1000 ; 
}
int main() { 
    int a, b; 
    while(1) {
        cin>>a>>b;
        if (a  == 0 && b == 0 ) {
            break ; 
        }
        cout<<qmi(a,b)<<endl;
    }
    return 0;
}

vj题目链接

todo

[Hdu] 数学基础

Sun, 04 May 2025 00:00:00 +0000

引导问题

整数求和

Hey, welcome to HDOJ(Hangzhou Dianzi University Online Judge).

In this problem, your task is to calculate SUM(n) = 1 + 2 + 3 + ... + n.

Input
The input will consist of a series of integers n, one integer per line.

Output
For each case, output SUM(n) in one line, followed by a blank line. You may assume the result will be in the range of 32-bit signed integer.

常规做法是 for-each 后对 sum 进行累加，然后输出
我们可以根据等差数列高斯公式求得 (a + b) * n / 2
不过这题需要注意的是 4. 我们计算乘法的时候可能暴 int , 因为对于两个 int32 的数相乘必然会爆 int32 所以我们需要开辟成 int64

题目链接如下, 由于不支持 GO 所以不做

https://vjudge.net/problem/HDU-1001

例题

最小公倍数

输入两个整数 a 和 b，请你编写一个函数，int lcm(int a, int b)，计算并输出 a 和 b 的最小公倍数。

输入格式
共一行，包含两个整数 a 和 b。

输出格式
共一行，包含一个整数，表示 a 和 b 的最小公倍数。

数据范围
1≤a,b≤1000

输入样例：
6 8
输出样例：
24

朴素做法

我们从最大的数开始枚举，如 8,9,10… 每次都判断是否能整除最小数
简单优化，我们可以直接枚举最大数的倍数。可是最大数的倍数, 我们有很大概率爆int 的风险

正解

lcm(A,B) = A * B / gcd(A,B)
优化一下 = A / gcd(A,B) * B
问题引导为 如何求最大公约数

Acwing-最小公倍数

最大公约数

我们现在要求 10, 14 的最大公约数。
我们假设 X 为这两个数的最大公约数，可以知道，对于 (14%10) 的余数，也应该是 X 的倍数
从而我们可以依次类推 (10,14) , (10,4) , (2,4), (2,0) 则 2 就是最大公约数

todo : 很抓马的一件事，我用 go 写这个程序 TLE 了

package main

import(
    "fmt"
)

func gcd(a,b int) int {
    if a > b {
        a,b = b,a
    }    
    for ; a != 0 ;  {
        a, b = b%a,a
    }
    return b 
}

func main() {
    var n int 
    fmt.Scan(&n)
    for i := 0 ; i < n ; i ++ {
        var a,b int 
        fmt.Scan(&a,&b)
        fmt.Println(gcd(a,b))
    }
}

#include <iostream> 
using namespace std ;
int gcd(int a,int b)  {
    int temp ; 
    if(a > b) {
        temp = a;
        a = b ;
        b = temp;
    } 
    for( ; a != 0 ; ) {
        temp = a;
        a = b%a;
        b = temp ;
    }
    return b ; 
}

int main() {
    int a,b ;
    int n;
    cin>>n;
    for(int i  = 1; i <= n ; i ++ ) {
        cin>>a>>b;
        cout<<gcd(a,b)<<endl;
    }
}

循环节 - N * N 的个位数

Given a positive integer N, you should output the most right digit of N^N.

Input

The input contains several test cases. The first line of the input is a single integer T which is the number of test cases.

T test cases follow.

Each test case contains a single positive integer N(1<=N<=1,000,000,000).

Output

For each test case, you should output the rightmost digit of N^N.

时间范围 : T * N 必然做法是 T * O(K) 的

2,4,8,16,32,64,128 ... 3,9,27,81,243 ...

显然，奇数 * 奇数 = 奇数，偶数 * 偶数 = 偶数。个位上的偶数也就 (0,2,4,6,8) , 奇数 (1,3,5,7,9) 所以肯定是一个循环,
因此我们只需要枚举出前5个,找出不重复的循环节即可解出这道题

#include <iostream> 
#include <math.h>
using namespace std;
int main() {
    int t;cin>>t;
    while(t -- ) {
        int n ; cin >> n; 
        int st[10] = {0};
        
        int last = n % 10 ;
        int ans[6] = {0} ;
        int idx = 0 ;
        
        for(int i = 0 ; i < 5 ; i++ ) {
            int k = int(pow(last, i + 1)) % 10; 
            if(st[k]){
                break ; 
            }
            ans[++idx] = k ; 
            st[k] = 1 ; 
        }
        ans[0] = ans[idx] ; 
        cout<<ans[(n%(idx)) ] <<endl; 
        idx = 0 ;
    }
    return 0; 
}

题目链接

[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 
}

算法 on GzzhM

[LeetCode][hot100] 图论

200. 岛屿数量

994.腐烂的橘子

207. 课程表

208. 实现 Trie (前缀树)

[LeetCode][hot100] 滑动窗口

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

心路历程

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

心路历程

[Acwing] 基础算法(十一) 欧拉函数

欧拉函数

算法思路

代码

时间复杂度

[Acwing] 基础算法(十) 约数

约数

试除法求约数

算法思路

代码

时间复杂度

约数个数

算法思路

代码

时间复杂度

约数之和

算法思路

代码

时间复杂度

最大公约数

算法思路

代码

时间复杂度

[Acwing] 基础算法(九) 质数

质数

试除法判定质数

算法思路

时间复杂度

分解质因数

算法思路

代码

时间复杂度

筛质数

埃及筛

算法思路

代码

时间复杂度

线性筛

代码

时间复杂度

[Acwing] 基础算法(八) 堆

Heap

算法思路

代码

时间复杂度分析

模拟堆

代码

一些感想

[Acwing] 基础算法(七) Tire 树

Tire

算法思路

代码展示

[Acwing] 基础算法（七) 并查集

并查集

算法思路

代码

[Acwing] 基础算法(六) 数据结构 栈&队列

栈

算法思路

代码

队列

算法思路

代码

单调栈

算法思路

代码

时间复杂度分析

单调队列

算法思路

[Acwing] 基础算法(六) 数据结构栈&队列

[Acwing] 基础算法（五) 数据结构链表