Acwing on GzzhM

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

[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 ，然后还加上递归回溯的处理，导致整个过程比较难理解

Acwing on GzzhM

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

欧拉函数

算法思路

代码

时间复杂度

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

约数

试除法求约数

算法思路

代码

时间复杂度

约数个数

算法思路

代码

时间复杂度

约数之和

算法思路

代码

时间复杂度

最大公约数

算法思路

代码

时间复杂度

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

质数

试除法判定质数

算法思路

时间复杂度

分解质因数

算法思路

代码

时间复杂度

筛质数

埃及筛

算法思路

代码

时间复杂度

线性筛

代码

时间复杂度

[Acwing] 基础算法(八) 堆

Heap

算法思路

代码

时间复杂度分析

模拟堆

代码

一些感想

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

Tire

算法思路

代码展示

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

并查集

算法思路

代码

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

栈

算法思路

代码

队列

算法思路

代码

单调栈

算法思路

代码

时间复杂度分析

单调队列

算法思路

代码

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

链表

单链表

算法思路

完整代码

双链表

算法思路

代码

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

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

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