CSPS模板

CSPS模板

目录

  • 一、字符串
    • 字符串哈希
    • Manacher
    • KMP
    • 字典树
  • 二、数据结构
    • 单调队列/单调栈
    • 树状数组/线段树
    • 扫描线
    • 笛卡尔树
  • 三、图论
    • LCA
    • 最小生成树
    • 最短路
    • 欧拉路径
    • 缩点
    • 割点
    • 点双连通分量
    • 边双连通分量
  • 四、数学
    • 模意义下的乘法逆元
    • exgcd
    • exCRT
    • 矩阵快速幂
    • 高斯消元
    • 三分
    • 线性筛
  • 五、待补充
    • 笛卡尔树

一、字符串

字符串哈希

很万能,不会的字符串状物可以上二分哈希,具体地,维护一个前缀的 \(hsh\),然后比如求 \(LCP\),可以直接二分一下 \(len\),看一下是否相等就完了。

代码非常好写,扔个封装了的板子吧(一般还是双哈希稳定一点,顺便给几个好记的质数:1e13+259,0x0d00721,如果场上写的话ull自然溢出是和好选择)

class Hash{
    private:
        string s;
        int n;
        int *h1, *h2;
        int *p1, *p2;
        static const int mod_1 = 1000000007;
        static const int mod_2 = 1000000009;
        static const int base = 131;
    public:
        Hash(string s1, function<int(char)> to_int, bool inv = false) : n(s1.size()){
            if(inv) s = string(s1.rbegin(), s1.rend());
            else s = s1;
            n = s.size();
            h1 = new int[n + 5];
            h2 = new int[n + 5];
            p1 = new int[n + 5];
            p2 = new int[n + 5];
            p1[0] = p2[0] = 1;
            rep(i, 1, n){
                p1[i] = p1[i - 1] * base % mod_1;
                p2[i] = p2[i - 1] * base % mod_2;
            }
            h1[0] = h2[0] = 0;
            rep(i, 1, n){
                int val = to_int(s[i - 1]);
                h1[i] = (h1[i - 1] * base + val) % mod_1;
                h2[i] = (h2[i - 1] * base + val) % mod_2;
            }
        }
        ~Hash(){
            delete[] h1;
            delete[] h2;
            delete[] p1;
            delete[] p2;
        }
        Hash(const Hash& other) : s(other.s), n(other.n){
            h1 = new int[n + 5];
            h2 = new int[n + 5];
            p1 = new int[n + 5];
            p2 = new int[n + 5];
            memcpy(h1, other.h1, sizeof(int) * (n + 5));
            memcpy(h2, other.h2, sizeof(int) * (n + 5));
            memcpy(p1, other.p1, sizeof(int) * (n + 5));
            memcpy(p2, other.p2, sizeof(int) * (n + 5));
        }
        Hash& operator=(const Hash& other){
            if (this == &other) return *this;
            delete[] h1;
            delete[] h2;
            delete[] p1;
            delete[] p2;
            s = other.s;
            n = other.n;
            h1 = new int[n + 5];
            h2 = new int[n + 5];
            p1 = new int[n + 5];
            p2 = new int[n + 5];
            memcpy(h1, other.h1, sizeof(int) * (n + 5));
            memcpy(h2, other.h2, sizeof(int) * (n + 5));
            memcpy(p1, other.p1, sizeof(int) * (n + 5));
            memcpy(p2, other.p2, sizeof(int) * (n + 5));
            return *this;
        }
        pii get(int l, int r) const{
            if(l > r) return {0, 0};
            int res1 = (h1[r] - h1[l - 1] * p1[r - l + 1] % mod_1 + mod_1) % mod_1;
            int res2 = (h2[r] - h2[l - 1] * p2[r - l + 1] % mod_2 + mod_2) % mod_2;
            return {res1, res2};
        }
        string get_str() const{
            return s;
        }
};

Manacher

解决回文串问题的利器,可以在线性时间内求出一个字符串中的最长回文子串,原理是利用回文对称性加速的暴力。

做法:

要求解每个位置 \(i\) 的最长回文半径 \(d(i)\)。

维护一个当前右端点最靠右的回文区间 \([l, r]\)。

  • 假设 \(d_1\sim d_{i-1}\) 都已经算出,现在要算 \(d_i\)。
  • 分情况讨论:
    • 若 \(i\leq r\),继续分情况讨论:
      • 若 \(d_{r-i+l}\leq r-i+1\),说明 \(d_i=d_{r-i+l}\),这是由于回文串的对称性。
      • 若 \(d_{r-i+l}>r-i+1\),由于不知道 \(r\) 指针右边的信息,只能令 \(d_i=r-i+1\),然后暴力扩展。
    • 若 \(i > r\),暴力扩展左右端点即可。
  • 更新右端点最大的回文区间。

常用来解决:最长回文子串、回文子串数量和求特定回文子串问题

int n, d[N], man[N]; string s; char t[N];
void solve(){
    cin >> s; t[n++] = '#'; for(char c : s) t[n++] = c, t[n++] = '#';
    int l = 0, r = -1; int mxlen = 0, mxst = 0; rep(i, 0, n - 1){
        int k = (i > r) ? 0 : min(d[l + r - i], r - i);
        while(i - k - 1 >= 0 && i + k + 1 < n && t[i - k - 1] == t[i + k + 1]) ++k;
        d[i] = k; if(i + k > r) l = i - k, r = i + k; int len = k + (((i & 1) ^ (k & 1)) ? 1 : 0);
        if(len > mxlen) mxlen = len, mxst = (i - k) / 2;
    } cout << mxlen;
}

KMP

解决单模式串匹配、最小循环节、字符串周期问题的利器。

定义:对于模式串 \(p\),记 \(nxt_i\) 为前缀 \(p[1..i]\) 中最长的真前缀等于真后缀的长度,即 Border 长度。

算法过程如下:匹配时维护双指针 \(i\) 与 \(j\)。其中 \(i\) 用于从左到右扫描主串 \(s\),\(j\) 表示当前模式串的前缀 \(p[1..j]\) 已经与 \(s\) 的某个后缀完全匹配。在遍历主串的过程中,若 \(s[i] = p[j+1]\),说明匹配推进,令 \(j = j + 1\)。若 \(s[i] \neq p[j+1]\),说明发生失配,此时主串指针 \(i\) 保持不动,让模式串指针回退,即令 \(j = nxt_j\)。当 \(j = m\)(\(m\) 为模式串长度)时,表示完成一次完整匹配,为了继续寻找后续匹配,同样令 \(j = nxt_j\)。

const int N = 1e7 + 5;

string s1, s2;
int nxt[N], n, m;
void getnxt(string t){
    int len = t.size(); t = ' ' + t;
    nxt[1] = 0;
    int j = 0;
    rep(i, 2, len){
        j = nxt[i - 1];
        while(j > 0 && t[j + 1] != t[i]) j = nxt[j];
        if(t[j + 1] == t[i]) nxt[i] = j + 1; else nxt[i] = 0;
    }
}
int l[N], tot;
void KMP(string t2, string t1){
    getnxt(t1); n = t2.size(), m = t1.size(); t1 = ' ' + t1; t2 = ' ' + t2;
    int j = 0;
    rep(i, 1, n){
        while(j > 0 && t1[j + 1] != t2[i]) j = nxt[j];
        if(t1[j + 1] == t2[i]) ++j;
        if(j == m) l[++tot] = i - j + 1, j = nxt[j];
    }   
}
void init(){
    cin >> s1 >> s2;
    KMP(s1, s2);
    rep(i, 1, tot) cout << l[i] << "\n";
    rep(i, 1, m) cout << nxt[i] << " ";
}   

字典树

用途比较多,一般分成 \(\text{普通Trie}\) 和 \(\text{01Trie}\) 两种,\(\text{普通Trie}\) 一般用来维护字符串前缀,做一些计数之类的,\(\text{01Trie}\) 可以维护异或最大和或者最大异或对之类的,可持久化 \(Trie\) 还可以用来维护区间 \(k\) 大之类的。

太好想了不解释了。

int cti[N];
class Trie{
    private:
        struct node{
            int son[62], siz;
        } t[N]; int tot = 62;
    public:
        void init(){rep(i, 0, 61) t[0].son[i] = i + 1; tot = 62;}
        void clr(){rep(i, 1, tot) init_0(t[i].son), t[i].siz = 0; tot = 62;}
        void ins(string s){ int now = 0;
            for(char c : s){
                int num = cti[c]; if(!t[now].son[num]) t[now].son[num] = ++tot;
                now = t[now].son[num]; ++t[now].siz;
            }
        }
        int query(string s){ int now = 0;
            for(char c : s){
                int num = cti[c]; if(!t[now].son[num]){now = -1; break;}
                now = t[now].son[num];
            } return ((~now) ? (t[now].siz) : (0));
        }
} T;

终于把字符串整完了


二、数据结构

单调队列/单调栈

一般用在优化 \(DP\) 上,形如 \(dp_i = \max_{j=k}^{i}dp_j\) 之类的形式,可以直接上单调队列/单调栈,还可以用来维护凸包状物。

单调队列

#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 1e6 + 5; int a[N], q[N], hd, tl, pos[N];
signed main(){
    ios::sync_with_stdio(0); cin.tie(0);
    int n, k; cin >> n >> k; hd = 1; tl = 0;
    for(int i = 1; i <= n; i++){ cin >> a[i];
        while(hd <= tl && q[tl] >= a[i]) --tl;
        q[++tl] = a[i]; pos[tl] = i; while(pos[hd] <= i - k) ++hd;
        if(i >= k) cout << q[hd] << " ";
    } cout << "\n"; hd = 1; tl = 0;
    for(int i = 1; i <= n; i++){
        while(hd <= tl && q[tl] <= a[i]) --tl;
        q[++tl] = a[i]; pos[tl] = i; while(pos[hd] <= i - k) ++hd;
        if(i >= k) cout << q[hd] << " ";
    }
    return 0;
}

单调栈

int n, a[N], f[N], stk[N], top;
void solve(){
    cin >> n; rep(i, 1, n) cin >> a[i]; stk[0] = 0;
    dep(i, n, 1){
        while(top && a[stk[top]] <= a[i]) --top;
        f[i] = stk[top]; stk[++top] = i;
    } rep(i, 1, n) cout << f[i] << " ";
}

树状数组/线段树

板子非常简单,写起来简单无脑惹人爱

线段树1.5:动态开点线段树

int n, m, rt; 
class Segment_Tree{
    private:
        ull sum[N << 6], lzy[N << 6]; int ls[N << 6], rs[N << 6], tot;
        void up(int x){sum[x] = sum[ls[x]] + sum[rs[x]];}
        void push(int x, int l, int r, int v){lzy[x] += v; sum[x] += (r - l + 1) * v;}
        void down(int x, int l, int r){
            if(lzy[x]){
                int mid = mid(l, r); if(!ls[x]) ls[x] = ++tot; if(!rs[x]) rs[x] = ++tot;
                push(ls[x], l, mid, lzy[x]); push(rs[x], mid + 1, r, lzy[x]); lzy[x] = 0;
            }
        }
    public:
        void modify(int ql, int qr, ull val, int &x = rt, int l = 1, int r = n){
            if(ql > r || l > qr) return ; if(!x) x = ++tot; if(ql <= l && qr >= r) return push(x, l, r, val); int mid = mid(l, r);
            down(x, l, r); modify(ql, qr, val, ls[x], l, mid); modify(ql, qr, val, rs[x], mid + 1, r); up(x);
        }
        ull query(int ql, int qr, int x = rt, int l = 1, int r = n){
            if(ql > r || l > qr || !x) return 0; if(ql <= l && qr >= r) return sum[x]; int mid = mid(l, r);
            down(x, l, r); return query(ql, qr, ls[x], l, mid) + query(ql, qr, rs[x], mid + 1, r);
        }
} T;

线段树2:维护乘和加标记

int n, q, mod, a[N];
void Add(int &x, int y){(x + y >= mod) ? (x += y - mod) : (x += y);}
void Mul(int &x, int y){x = x * y % mod;}
int Mod(const int &x){return ((x >= mod) ? (x - mod) : ((x < 0) ? (x + mod) : x));}
class Segment_Tree{
    private:
        int sum[N << 2], lzy1[N << 2], lzy2[N << 2];
        void up(int x){sum[x] = Mod(sum[ls(x)] + sum[rs(x)]);}
        void push(int x, int l, int r, int val){Add(sum[x], (r - l + 1) * val % mod); Add(lzy1[x], val);}
        void push1(int x, int val){Mul(sum[x], val); Mul(lzy1[x], val); Mul(lzy2[x], val);}
        void down(int x, int l, int r){
            int mid = mid(l, r);
            if(lzy2[x] ^ 1){
                push1(ls(x), lzy2[x]);
                push1(rs(x), lzy2[x]);
                lzy2[x] = 1;
            }
            if(lzy1[x]){
                push(ls(x), l, mid, lzy1[x]);
                push(rs(x), mid + 1, r, lzy1[x]);
                lzy1[x] = 0;
            }
        }
    public:
        void build(int x = 1, int l = 1, int r = n){
            lzy1[x] = 0; lzy2[x] = 1; if(l == r) return push(x, l, r, a[l]); int mid = mid(l, r);
            build(ls(x), l, mid); build(rs(x), mid + 1, r); up(x);
        }
        void add(int ql, int qr, int val, int x = 1, int l = 1, int r = n){
            if(ql > r || l > qr) return ; if(ql <= l && qr >= r) return push(x, l, r, val); int mid = mid(l, r);
            down(x, l, r); add(ql, qr, val, ls(x), l, mid); add(ql, qr, val, rs(x), mid + 1, r); up(x);
        }
        void mul(int ql, int qr, int val, int x = 1, int l = 1, int r = n){
            if(ql > r || l > qr) return ; if(ql <= l && qr >= r) return push1(x, val); int mid = mid(l, r);
            down(x, l, r); mul(ql, qr, val, ls(x), l, mid); mul(ql, qr, val, rs(x), mid + 1, r); up(x);
        }
        int query(int ql, int qr, int x = 1, int l = 1, int r = n){
            if(ql > r || l > qr) return 0; if(ql <= l && qr >= r) return sum[x]; int mid = mid(l, r);
            down(x, l, r); return Mod(query(ql, qr, ls(x), l, mid) + query(ql, qr, rs(x), mid + 1, r));
        }
} T;

容易犯错的地方:lzy考虑是否会有0的请况?有无漏写down?

说点小技巧,标记永久化,可以解决下传懒标记在某些时候会出错的问题(比如矩形面积并),也可以用来减少主席树的点数或者做李超线段树。

扫描线

就是离线把问题按某一维排序,依次处理“事件”,用数据结构动态维护另一维的信息。常见题目就是 矩形面积并 / 周长并、二维数点 / 矩形内点数、区间查询 + 离线排序、偏序、区间加删问题之类的吧。

这里给出矩形面积并和二维数点代码(都是扫描线)

矩阵面积并

#include<bits/stdc++.h>
#define ls p<<1
#define rs p<<1|1
using namespace std;
typedef long long ll;
const int N=1e5+5;

struct Line{
    ll l,r,h;
    int f;
    bool operator<(const Line &b)const{
        if(h==b.h)return f>b.f;
        return h<b.h;
    }
}line[N<<3];
ll x[N<<3];
struct Node{
    int l,r,cnt;
    ll len;
}t[N<<3];
void build(int p,int l,int r){
    t[p].l=l,t[p].r=r;
    t[p].cnt=t[p].len=0;
    if(l==r)return;
    int mid=l+r>>1;
    build(ls,l,mid);
    build(rs,mid+1,r);
}
void pu(int p){
    if(t[p].cnt) t[p].len=x[t[p].r+1]-x[t[p].l];
    else t[p].len=(t[p].l==t[p].r)?0:t[ls].len+t[rs].len;
}
void modify(int p,ll l,ll r,int f){
    if(x[t[p].r+1]<=l || x[t[p].l]>=r) return;
    if(l<=x[t[p].l] && x[t[p].r+1]<=r){
        t[p].cnt+=f;
        pu(p);
        return;
    }
    modify(ls,l,r,f);
    modify(rs,l,r,f);
    pu(p);
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int n;cin>>n;
    for(int i=1;i<=n;i++){
        ll x1,y1,x2,y2;
        cin>>x1>>y1>>x2>>y2;
        x[2*i-1]=x1,x[2*i]=x2;
        line[2*i-1]={x1,x2,y1,1};
        line[2*i]={x1,x2,y2,-1};
    }
    n<<=1;
    sort(line+1,line+n+1);
    sort(x+1,x+n+1);
    int tot=unique(x+1,x+n+1)-x-1;
    build(1,1,tot-1);
    ll ans=0;
    for(int i=1;i<n;i++){
        modify(1,line[i].l,line[i].r,line[i].f);
        ans+=t[1].len*(line[i+1].h-line[i].h);
    }
    cout<<ans<<"\n";
    return 0;
}

离线二维数点

struct NODE{int x, id, val;};
int n, m, a[N]; vector<NODE> node[N];
class BIT{
    private:
        int t[N];
    public:
        int get(int x, int ret = 0){
            for(int i = x; i; i -= (i & -i)) ret += t[i];
            return ret;
        }
        void add(int x, int val){
            for(int i = x; i <= N; i += (i & -i)) t[i] += val;
        }
        int query(int l, int r){
            return get(r) - get(l - 1);
        }
} b; int res[N];
void init(){
    cin >> n >> m; rep(i, 1, n) cin >> a[i];
    rep(i, 1, m){
        int l, r, x; cin >> l >> r >> x;
        node[l - 1].pb({x, i, -1});
        node[r].pb({x, i, 1});
    } rep(i, 1, n){
        b.add(a[i], 1);
        for(const auto &[x, id, val] : node[i]) res[id] += val * b.get(x);
    } rep(i, 1, m) cout << res[i] << "\n";
}

笛卡尔树

image

1. 定义与核心性质

笛卡尔树是一种将序列与二叉树结合的特定数据结构。对于给定的序列 \(a\),其笛卡尔树是一棵二叉树,且严格满足以下两个性质:
1.堆性质:若建立的是小根笛卡尔树,则父节点的值小于等于子节点的值;若为大根笛卡尔树,则父节点大于等于子节点。
2.中序遍历性质:对笛卡尔树进行中序遍历,得到的节点顺序恰好是原序列 \(a\) 的顺序。

这意味着,笛卡尔树的根节点一定是原序列的最小(或最大)值,且其左子树对应原序列根节点左侧的连续区间,右子树对应右侧的连续区间。这种递归的区间划分结构,是解决区间问题的关键。

2. 构造方法

利用单调栈可以在 \(O(N)\) 的时间复杂度内建树。以小根笛卡尔树为例,核心是维护一条最右链(即从根节点一直往右儿子走形成的路径)。
遍历序列中的每个元素:

  • 若当前元素大于栈顶元素,直接将其作为栈顶元素的右儿子,并入栈。
  • 若当前元素小于栈顶元素,则不断弹出栈顶,直到栈空或栈顶元素小于当前元素。此时,最后一个弹出的元素作为当前元素的左儿子,当前元素作为此时栈顶的右儿子。

3. 性质

1.区间最值恰好为LCA
2.直方图最大矩形面积:以直方图高度为权值建立小根笛卡尔树,每个节点对应的子树大小即为以该高度为限制能延伸的最宽矩形范围。
3.优化划分型DP:当 DP 的转移依赖于区间的最大值或最小值作为分割点时,可以直接在笛卡尔树上进行树形 DP。子树天然对应连续区间,省去了枚举分割点的过程。
4.区间合并类问题:结合启发式合并(DSU on Tree),笛卡尔树可以高效处理子树信息合并,尤其适用于与区间最值相关的统计问题。

int n, p[N], ls[N], rs[N], stk[N], top;
void solve(){
    cin >> n; rep(i, 1, n) cin >> p[i]; stk[++top] = 1;
    rep(i, 2, n){
        while(top && p[stk[top]] > p[i]) --top;
        if(!top) ls[i] = stk[top + 1]; else ls[i] = rs[stk[top]], rs[stk[top]] = i;
        stk[++top] = i;
    }
}

三、图论

LCA

一般有倍增求和ST表求两种。

ST表:先DFS出欧拉序,记录每个点第一次出现的位置 \(fir_x\) 和深度 \(dep_x\),对 \(dep_x\) 建立ST表,维护深度最小位置的下标,\(LCA(x,y)\) 就是 \(fir_x\) 到 \(fir_y\) 之间深度最小的位置。

namespace LCA{
	int euler[N << 1], dep[N << 1], fir[N], cnt;
	int st[N << 1][20];
	void dfs_euler(int x, int fa){
		fir[x] = ++cnt;
		euler[cnt] = x;
		dep[cnt] = dep[fir[fa]] + 1;
		for(int y : vc[x]) if (y ^ fa){
			dfs_euler(y, x);
			euler[++cnt] = x;
			dep[cnt] = dep[fir[x]];
		}
	}
	void build_st(){
		rep(i, 1, cnt) st[i][0] = i;
		for(int j = 1; (1 << j) <= cnt; ++j) rep(i, 1, cnt - (1 << j) + 1){
			int a = st[i][j - 1], b = st[i + (1 << (j - 1))][j - 1];
			st[i][j] = dep[a] < dep[b] ? a : b;
		}
	} int lca(int u, int v){
		int l = fir[u], r = fir[v];
		if (l > r) swap(l, r);
		int k = __lg(r - l + 1);
		int a = st[l][k], b = st[r - (1 << k) + 1][k];
		return dep[a] < dep[b] ? euler[a] : euler[b];
	}
	void Build(){dfs_euler(s, s); build_st();}
}
using LCA::lca;

倍增求LCA:思路很简单,一般比较通用,除了 \(LCA\) 倍增还可以用来维护一条链的权值,更进一步还可以进行倍增优化建图。

int n, m, fa[N][21], dep[N]; vector<int> vc[N];
void dfs(int x = 1, int f = 1){
    fa[x][0] = f; dep[x] = dep[f] + 1; rep(i, 1, 20) fa[x][i] = fa[fa[x][i - 1]][i - 1];
    for(const int &y : vc[x]) if(y ^ f) dfs(y, x);
}
int LCA(int x, int y){
    if(dep[x] < dep[y]) swap(x, y);
    dep(i, 20, 0) if(dep[fa[x][i]] >= dep[y]) x = fa[x][i];
    if(x == y) return x;
    dep(i, 20, 0) if(fa[x][i] ^ fa[y][i]) x = fa[x][i], y = fa[y][i];
    return fa[x][0];
}

最小生成树

\(Kruskal\) 基本上够用了,直接给边按照边权排序,暴力并查集合并即可

int n, m;
class bcj{
    private:
        int fa[N], siz[N];
    public:
        void init(){
            rep(i, 1, n) fa[i] = i, siz[i] = 1;
        }
        int find(int x){return fa[x] == x ? x : fa[x] = find(fa[x]);}
        bool merge(int x, int y){
            x = find(x), y = find(y);
            if(x == y) return 0;
            if(siz[x] < siz[y]) swap(x, y);
            fa[y] = x;
            siz[x] += siz[y];
            return 1;
        }
} b;
struct Edge{int u, v, w;} e[N];
void solve(){
    cin >> n >> m; b.init();
    rep(i, 1, m) cin >> e[i].u >> e[i].v >> e[i].w;
    sort(e + 1, e + m + 1, [](const Edge &a, const Edge &b){return a.w < b.w;});
    int cnt = 0, ans = 0; rep(i, 1, m){if(b.merge(e[i].u, e[i].v)) ++cnt, ans += e[i].w; if(cnt == n - 1) break;}
    if(cnt == n - 1) cout << ans << "\n"; else cout << "orz\n";
}

\(Kruskal\) 还可以用来做重构树,用来处理最小瓶颈路问题(转化为重构树上 \(val[LCA(u,v)]\))

建树过程:按边权从小到大做 \(Kruskal\),每次合并两个不同连通块时:

  1. 新建节点 x,点权 val[x] = 当前边权;
  2. 两个连通块的代表节点作为 x 的左右儿子;
  3. 并查集把两块代表都指向 x。

最短路

关于Spfa,它死了。

所以我们在处理无负边权的单源最短路问题上还是选择dij吧,直接拿pq维护即可,很好写。

pq<pii, vector<pii>, greater<pii>> q; rep(i, 1, n) vis[i] = 0, dis[i] = inf64; dis[1] = 0; q.push({0, 1});
while(!q.empty()){
    auto [d, x] = q.top(); q.pop(); if(vis[x]) continue; vis[x] = 1;
    for(const auto&[y, w] : vc[x]){
        if(dis[y] > dis[x] + w){
            dis[y] = dis[x] + w;
            q.push({dis[y], y});
        }
    }
}

有负边的时候还是得上 \(Spfa\),只是说复杂度是 \(O(nm)\) 量级了。

vector<pii> vc[N];
int h[N], cnt[N]; bool vis[N];
bool spfa(int s){ rep(i, 1, n) vis[i] = 0, h[i] = inf64;
    queue<int> q; q.push(s); vis[s] = 1; h[s] = 0;
    while(!q.empty()){
        int x = q.front(); q.pop(); vis[x] = 0;
        for(const auto &[y, w] : vc[x]) if(h[y] > h[x] + w){
            h[y] += w; if(vis[y]) continue;
            vis[y] = 1; q.push(y); ++cnt[y]; if(cnt[y] == n + 1) return 0;
        }
    } return 1;
}

拓展一下01BFS,当遇到边权只有0,1的图的时候,可以把复杂度降低到 \(O(n+m)\)

考虑维护一个双端队列 deque:

  1. 每次从队头取出当前距离最小的点 u;
  2. 扩展边 (u, v, w),其中 w ∈ {0, 1}:
    • 若 w = 0:v 的距离和 u 相同,push_front(v)
      (优先处理,保持队列单调);
    • 若 w = 1:v 的距离是 dis[u] + 1,push_back(v)。

正确性非常显然。

处理多源最短路问题上一般 \(Floyd\) 足以, \(O(N^3)\) 够用了

rep(k, 1, n) rep(i, 1, n) rep(j, 1, n)
floyd[i][j] = min(floyd[i][j], floyd[i][k] + floyd[k][j]);

当然来都来顺手看一下 \(Johnson\),其实很简单:

建一个虚拟 \(0\) 节点,将它与所有其他边连一条边权为 \(0\) 的边,跑一下 \(\text{Bellman-Ford(SPFA)}\) 求出 \(0\) 到其他所有点的最短路,记作 \(h_i\),然后我们把 \(u\to v\) 的边权从 \(w\) 改成 \(w+h_u-h_v\),然后每个点分别dij即可,复杂度 \(O(nm\log{m})\)。

int n, m;
vector<pii> vc[N];
int h[N], cnt[N]; bool vis[N];
bool spfa(int s){ rep(i, 1, n) vis[i] = 0, h[i] = 1e9, cnt[i] = 0;
    queue<int> q; q.push(s); vis[s] = 1; h[s] = 0;
    while(!q.empty()){
        int x = q.front(); q.pop(); vis[x] = 0;
        for(const auto &[y, w] : vc[x]) if(h[y] > h[x] + w){
            h[y] = h[x] + w; if(vis[y]) continue;
            vis[y] = 1; q.push(y); ++cnt[y]; if(cnt[y] == n + 2) return 0;
        }
    } return 1;
}
int dis[N][N];
void dij(int x){ rep(i, 1, n) dis[x][i] = 1e9, vis[i] = 0;
    pq<pii, vector<pii>, greater<pii>> q; q.push({0, x}); dis[x][x] = 0; while(!q.empty()){
        auto[d, u] = q.top(); q.pop(); if(vis[u]) continue; vis[u] = 1;
        for(const auto &[v, w] : vc[u]) if(dis[x][v] > dis[x][u] + w + h[u] - h[v]){
            dis[x][v] = dis[x][u] + w + h[u] - h[v]; q.push({dis[x][v], v});
        }
    }
}
void init(){
    cin >> n >> m;
    rep(i, 1, m){
        int u, v, w; cin >> u >> v >> w;
        vc[u].pb({v, w});
    } rep(i, 1, n) vc[0].pb({i, 0});
    if(!spfa(0)) return void(cout << "-1\n"); rep(i, 1, n) dij(i);
}

然后是最短路的应用,说一下差分约束,

给出 \(n\) 个变量和 \(m\) 个约束条件,形如 \(x_i - x_j \leq c_k\),你需要求出一组解,使得所有约束条件均被满足。

变形得:\(x_i \leq x_j + c_k\)

容易发现这个形式和最短路中的三角形不等式 \(dis_v \leq dis_u + w\) 非常相似。

因此我们就将这个问题转化为一个求最短路的问题:比如对于上面这个不等式,我们从 \(j\) 向 \(i\) 连一条权值为 \(c_k\) 的边。

接下来,我们再新建一个 \(0\) 号点,从 \(0\) 号点向其他所有点连一条权值为 \(0\) 的边。

这个操作相当于新增了一个变量 \(x_0\) 和 \(n\) 个约束条件:\(x_i \leq x_0\),从而将所有变量都和 \(x_0\) 这一个变量联系起来。

然后以 \(0\) 号点为起点,用 Bellman-Ford 跑最短路。如果有负权环,差分约束系统无解。否则设从 \(0\) 号点到 \(i\) 号点的最短路为 \(dis_i\),则 \(x_i = dis_i\) 即为差分约束系统的一组可行解。

欧拉路径

  • 有向图欧拉路径:图中恰好存在 \(1\) 个点出度比入度多 \(1\)(这个点即为起点 \(S\)),\(1\) 个点入度比出度多 \(1\)(这个点即为终点 \(T\)),其余节点出度=入度。
  • 有向图欧拉回路:所有点的入度=出度(起点 \(S\) 和终点 \(T\) 可以为任意点)。
  • 无向图欧拉路径:图中恰好存在 \(2\) 个点的度数是奇数,其余节点的度数为偶数,这两个度数为奇数的点即为欧拉路径的起点 \(S\) 和终点 \(T\)。
  • 无向图欧拉回路:所有点的度数都是偶数(起点 \(S\) 和终点 \(T\) 可以为任意点)。

求路径直接暴力 \(dfs\) 即可。

int vis[N]; int n, m; vector<int> vc[N];
int stk[N], top;
void dfs(int x){
    for(int i = vis[x]; i < vc[x].size(); i = vis[x]) vis[x] = i + 1, dfs(vc[x][i]); stk[++top] = x;
} int id[N], od[N];
void init(){
    cin >> n >> m; rep(i, 1, m){
        int u, v; cin >> u >> v; vc[u].pb(v); ++id[v]; ++od[u];
    } rep(i, 1, n) sort(vc[i].begin(), vc[i].end());
    bool f = 0; int st = 1, inc = 0, outc = 0; rep(i, 1, n) if(id[i] ^ od[i]){
        f = 1; if(od[i] - id[i] == 1) ++outc, st = i; else if(id[i] - od[i] == 1) ++inc;
        else return void(cout << "No\n");
    } if(f && !(inc == outc && inc == 1)) return void(cout << "No\n"); dfs(st);
    while(top) cout << stk[top--] << " ";
}

缩点

有向图缩点直接写 \(Tajan\) 即可,代码很简单,有个好性质,就是跑完以后,\(1\to col\) 的顺序恰好是逆拓扑序,可以直接DP,不需要重新拓扑排序。

int n, m, a[N], b[N], dp[N];
vector<int> g[N], vc[N];
int dfn[N], low[N], cnt, stk[N], top, col, scc[N]; bool in[N];
void Tarjan(int x){
    low[x] = dfn[x] = ++cnt; stk[++top] = x; in[x] = 1;
    for(int y : g[x]){
        if(!dfn[y]){
            Tarjan(y); low[x] = min(low[x], low[y]);
        } else if(in[y]) low[x] = min(low[x], dfn[y]);
    } if(dfn[x] == low[x]){
        ++col; int tp; do{
            tp = stk[top--]; in[tp] = 0; scc[tp] = col; b[col] += a[tp];
        } while(tp ^ x);
    }
}
void init(){
    cin >> n >> m; rep(i, 1, n) cin >> a[i]; rep(i, 1, m){int u, v; cin >> u >> v; g[u].pb(v);}
    rep(i, 1, n) if(!dfn[i]) Tarjan(i);
    rep(x, 1, n) for(int y : g[x]) if(scc[x] ^ scc[y]) vc[scc[x]].pb(scc[y]);
    int res = -1; dep(x, col, 1){
        for(int y : vc[x]) dp[y] = max(dp[x] + b[x], dp[y]);
        res = max(res, (dp[x] += b[x]));
    } cout << res << "\n";
}

割点

直接 \(Tarjan\) 做很好想,如果当前点是根,那么直接判他是否有两个以上子树,如果不是根,显然就是存在一个孩子的 \(low\) 不比这个点的 \(dfn\) 小,直接写就行。

int n, m, cnt;
vector<int> vc[N];
int rt, dfn[N], low[N], tot, fa[N]; bool gd[N];
void Tarjan(int x){
    dfn[x] = low[x] = ++tot; int c = 0; for(int y : vc[x]){
        if(!dfn[y]){
            Tarjan(y); low[x] = min(low[x], low[y]); ++c;
            if(low[y] >= dfn[x] && x ^ rt && !gd[x]) gd[x] = 1, ++cnt;
        } else if(fa[y] ^ x) low[x] = min(low[x], dfn[y]);
    } if(x == rt && !gd[x] && c >= 2) gd[x] = 1, ++cnt;
}
void init(){
    cin >> n >> m;
    rep(i, 1, m){int u, v; cin >> u >> v; vc[u].pb(v); vc[v].pb(u);}
    rep(i, 1, n) if(!dfn[i]) rt = i, Tarjan(i);
    cout << cnt << "\n"; rep(i, 1, n) if(gd[i]) cout << i << " ";
}

点双连通分量

#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5, M = 8e6 + 5;

int tot = 1, hd[M];
int dcc, low[N], dfn[N], cnt, n, m;
struct edge{
	int nxt, to;
}e[M];
vector<int> ans[M];
stack<int> st;
inline void add(int u, int v){
    e[++tot].to = v;
    e[tot].nxt = hd[u];
    hd[u] = tot;
}

inline void tarjan(int u, int fa){
    int c = 0;
    low[u] = dfn[u] = ++cnt;
    st.push(u);
    for(int i = hd[u]; i; i = e[i].nxt){
        int v = e[i].to;
	    if(!dfn[v]){//树边 
	    	c++;
            tarjan(v, u);
            low[u] = min(low[u], low[v]);
            if(low[v] >= dfn[u]){
                dcc++;
                while(1){
                    int x = st.top(); st.pop();
                    ans[dcc].push_back(x);
                    if(x == v) break;
                }
                ans[dcc].push_back(u);
            }
        }
        else if(v != fa)low[u] = min(low[u], dfn[v]);//返祖边 
    }
    if(fa == 0 && c == 0) ans[++dcc].push_back(u);
}

int main(){
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= m; i++){
        int u, v; cin >> u >> v;
        add(u, v); add(v, u);
    }
    
    for(int i = 1; i <= n; i++)
        if(!dfn[i]){
        	while(!st.empty())st.pop();
			tarjan(i, 0);
		}
    
    cout << dcc << "\n";
    for(int i = 1; i <= dcc; i++){
        cout << ans[i].size();
        for(int x : ans[i]) cout << " " << x;
        cout << "\n";
    }
    return 0;
}

边双连通分量

#include<bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, M = 2e6 + 5;

int n, m, tot = 1, cnt;
int hd[N], dfn[N], low[N], bri[M<<1], id[N];
vector<int> ans[N];
struct Edge{
    int to, nxt;
}e[M<<1];

void add(int u, int v) {
    e[++tot] = {v, hd[u]};
    hd[u] = tot;
}

void tarjan(int x, int y) {
    dfn[x] = low[x] = ++cnt;
    for(int i = hd[x]; i; i = e[i].nxt) {
        int v = e[i].to;
        if(!dfn[v]) {
            tarjan(v, i);
            low[x] = min(low[x], low[v]);
            if(low[v] > dfn[x]) 
                bri[i] = bri[i^1] = 1;
        }
        else if(i != (y^1))
            low[x] = min(low[x], dfn[v]);
    }
}

void dfs(int x, int now) {
    id[x] = now;
    ans[now].push_back(x);
    for(int i = hd[x]; i; i = e[i].nxt) {
        int v = e[i].to;
        if(id[v] || bri[i]) continue;
        dfs(v, now);
    }
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    cin >> n >> m;
    while(m--) {
        int u, v; cin >> u >> v;
        add(u, v), add(v, u);
    }
    
    for(int i = 1; i <= n; ++i)
        if(!dfn[i]) tarjan(i, 0);
    
    int cnt = 0;
    for(int i = 1; i <= n; ++i)
        if(!id[i]) dfs(i, ++cnt);
    
    cout << cnt << "\n";
    for(int i = 1; i <= cnt; ++i) {
        cout << ans[i].size();
        for(int x : ans[i]) cout << " " << x;
        cout << "\n";
    }
    return 0;
}

四、数学

模意义下的乘法逆元

充分发扬人类智慧,不想推式子,直接求出阶乘逆元,然后i的逆元就是inv(i!)*(i-1)!

int frac[N], inv[N];
int n, p;
void init(){
    cin >> n >> p; frac[0] = 1; rep(i, 1, n) frac[i] = frac[i - 1] * i % p;
    inv[n] = pw(frac[n], p - 2, p); dep(i, n - 1, 0) inv[i] = inv[i + 1] * (i + 1) % p;
    rep(i, 1, n) cout << inv[i] * frac[i - 1] % p << "\n";
}

exgcd

求解不定方程 \(ax + by = \gcd(a, b)\) (假设 \(a \ge b\))

当 \(b = 0\) 时有 \(\gcd(a, b) = a\),此时 \(x = 1, y = 0\)。

当 \(b\) 不为 \(0\) 时,根据 GCD 递归定理 \(\gcd(a, b) = \gcd(b, a \bmod b)\)

可得 \(ax + by = \gcd(a, b) = \gcd(b, a \bmod b) = bx' + (a \bmod b)y'\)

即 \(ax + by = bx' + (a \bmod b)y' = bx' + (a - b * \lfloor a/b \rfloor)y'\)

移项得 \(ax + by = bx' + (a \bmod b)y' = ay' + b(x' - \lfloor a/b \rfloor y')\)

所以 \(x = y', y = x' - \lfloor a/b \rfloor y'\)

设 \((x_0, y_0)\) 是不定方程 \(ax + by = m\) 的一组解,\((a, b) = g\),那么全部解为 \((x_0 + (b/g)t, y_0 - (a/g)t)\),其中 \(t\) 为所有整数。

int x, y, c, d;
void exgcd(int a, int b){
    if(!b) return x = 1, y = 0, void(); exgcd(b, a % b);
    int tmp = x; x = y; y = tmp - a / b * y;
} int a, b;
void solve(){
    cin >> a >> b >> c; d = __gcd(a, b); if(c % d) return void(cout << "-1\n");
    exgcd(a, b); x *= c / d; y *= c / d; int tx = b / d, ty = a / d;
    int k = ceil((1.0 - x) * 1.0 / tx);
    x += tx * k; y -= ty * k; if(y <= 0){
        cout << x << " " << y + ty * (int)ceil((1.0 - y) * 1.0 / ty) << "\n";
    }else{
        cout << (y - 1) / ty + 1 << " " << x << " " << (y - 1) % ty + 1 << " " << x + (y - 1) / ty * tx << " " << y << "\n";
    }
}

exCRT

虽然说板子是 \(CRT\),但我还是想写 \(exCRT\)。

求解同余方程组:

\[\begin{cases} x \equiv a_1 \pmod{m_1} \\ x \equiv a_2 \pmod{m_2} \\ \vdots \\ x \equiv a_n \pmod{m_n} \end{cases} \]

其中 \(m_i\) 不一定两两互质。

我们考虑将两个方程合并为一个方程。
对于前两个方程:

\[\begin{cases} x \equiv a_1 \pmod{m_1} \\ x \equiv a_2 \pmod{m_2} \end{cases} \]

可以将它们转化为不定方程:

\[x = a_1 + m_1 k_1 = a_2 + m_2 k_2 \]

移项得:

\[m_1 k_1 - m_2 k_2 = a_2 - a_1 \]

设 \(g = \gcd(m_1, m_2)\),根据裴蜀定理,当且仅当 \(g \mid (a_2 - a_1)\) 时,该方程有解。否则整个同余方程组无解。

若有解,我们用扩展欧几里得算法(exgcd)求出 \(m_1 u + m_2 v = g\) 的一组解 \((u, v)\)。
两边同乘 \(\frac{a_2 - a_1}{g}\),得到 \(k_1\) 的一个特解:

\[k_1 = u \cdot \frac{a_2 - a_1}{g} \]

为了防止溢出并求出最小正整数解,将其对 \(\frac{m_2}{g}\) 取模:

\[k_1 \leftarrow \left( u \cdot \frac{a_2 - a_1}{g} \right) \bmod \frac{m_2}{g} \]

将 \(k_1\) 代回 \(x = a_1 + m_1 k_1\),即可得到满足前两个方程的一个特解 \(x_0\)。
此时,所有满足前两个方程的解都可以表示为:

\[x = x_0 + \text{lcm}(m_1, m_2) \cdot t \quad (t \in \mathbb{Z}) \]

这等价于一个新的同余方程:

\[x \equiv x_0 \pmod{\text{lcm}(m_1, m_2)} \]

其中 \(\text{lcm}(m_1, m_2) = \frac{m_1 m_2}{g}\)。

不断重复上述合并过程,将新得到的方程与下一个方程合并,最终就可以得到整个方程组的解。
若中途出现 \(g \nmid (a_2 - a_1)\),则方程组无解。

void add(int &x, int y, int mod){x = (x + y) % mod;}
void Mod(int &x, int mod){x = ((x % mod) + mod) % mod;}
int mul(int a, int b, int p){
    int res = 0; Mod(a, p); Mod(b, p);
    while(b){
        if(b & 1) add(res, a, p);
        add(a, a, p); b >>= 1;
    }
    return res;
} int exgcd(int a, int b, int &x, int &y){
    if(!b) return x = 1, y = 0, a;
    int d = exgcd(b, a % b, y, x); y -= a / b * x; return d;
} int n, r[N], m[N];
int excrt(){
    int r1 = r[1], m1 = m[1];
    rep(i, 2, n){
        int r2 = r[i], m2 = m[i];
        int x, y; int d = exgcd(m1, m2, x, y), c = r2 - r1;
        if(c % d) return -1; int t = m2 / d; x = mul(x, (c / d) % t + t, t);
        r1 += mul(x, m1, m1 / d * m2); m1 = m1 / d * m2; Mod(r1, m1);
    } return r1;
}

void init(){
    cin >> n; rep(i, 1, n) cin >> m[i] >> r[i];
    cout << excrt();
}

矩阵快速幂

处理一类线性DP优化问题,特点就是某一位莫名非常大比如 \(m\leq 1e9\) 之类的,就有可能是求矩阵的m次方。

还可以做一些图的计数,典型的就是直接对 \(floyd\) 做快速幂求恰好经过 \(k\) 条边的最短路 。

常见的还有在AC自动机上优化DP和DDP(把转移方程写成矩阵乘法形式(max,+)或(min,+)等等)

int n, k;
void add(int &x, int y){(x + y >= mod) ? (x += y - mod) : (x += y);}
struct mat{
    int a[105][105];
    mat(){init_0(a);}
    mat operator*(const mat &ot) const{
        mat ret; rep(i, 1, n) rep(k, 1, n) rep(j, 1, n) add(ret.a[i][j], a[i][k] * ot.a[k][j] % mod); return ret;
    }
} mt, ret;
void qpw(mat x, int P, mat &ret){
    while(P){
        if(P & 1) ret = ret * x;
        x = x * x; P >>= 1;
    }
}
void init(){
    cin >> n >> k; rep(i, 1, n){rep(j, 1, n) cin >> mt.a[i][j]; ret.a[i][i] = 1;}
    qpw(mt, k, ret); rep(i, 1, n) rep(j, 1, n) cout << ret.a[i][j] << " \n"[j==n];
}

高斯消元

可以 \(O(n^3)\) 的求解线性方程组,过程:

给定一个包含 \(n\) 个未知数、\(m\) 个方程的线性方程组:

\[\begin{cases} a_{1,1}x_1 + a_{1,2}x_2 + \cdots + a_{1,n}x_n = b_1 \\ a_{2,1}x_1 + a_{2,2}x_2 + \cdots + a_{2,n}x_n = b_2 \\ \vdots \\ a_{m,1}x_1 + a_{m,2}x_2 + \cdots + a_{m,n}x_n = b_m \end{cases} \]

将其写成增广矩阵的形式:

\[\begin{bmatrix} a_{1,1} & a_{1,2} & \cdots & a_{1,n} & b_1 \\ a_{2,1} & a_{2,2} & \cdots & a_{2,n} & b_2 \\ \vdots & \vdots & \ddots & \vdots & \vdots \\ a_{m,1} & a_{m,2} & \cdots & a_{m,n} & b_m \end{bmatrix} \]

对于每一列 \(i\)(即第 \(i\) 个未知数):

  1. 从第 \(i\) 行及以下的行中,找到第 \(i\) 列绝对值最大的元素所在的行(列主元法,用于防止实数运算的精度误差)。
  2. 将该行与第 \(i\) 行交换。
  3. 若主元为 \(0\),说明该未知数是自由元,跳过该列,处理下一列。
  4. 用第 \(i\) 行消去下面所有行的第 \(i\) 个未知数。

消元完毕后,如果发现某一行出现 \(0 = b\)(\(b \neq 0\)),则方程组无解。

如果没有无解的情况,且非零行的数量 \(r < n\),则方程组有无穷多解(存在自由元)。

若 \(r = n\),则方程组有唯一解,此时可以从下往上回代,依次求出 \(x_n, x_{n-1}, \dots, x_1\)。

可以用来求矩阵的逆、求矩阵的秩、求行列式、求基底等等

const int N = 105;

int n; db a[N][N], b[N], res[N];
int guass(){
    rep(i, 1, n){
        int mx = i; rep(j, i + 1, n) if(fabs(a[j][i]) > fabs(a[mx][i])) mx = j;
        if(fabs(a[mx][i]) < eps) continue; swap(a[i], a[mx]); rep(j, 1, n) if(i ^ j){
            db r = a[j][i] / a[i][i]; rep(k, i, n + 1) a[j][k] -= a[i][k] * r;
        }
    } int f = 0, num = 0; rep(i, 1, n){
        f = 0; rep(j, 1, n) if(fabs(a[i][j]) > eps) f = 1;
        if(!f){if(fabs(a[i][n + 1]) > eps) return -1; ++num;}
    } if(num) return 0; rep(i, 1, n) res[i] = a[i][n + 1] / a[i][i]; return 1;
}
void init(){
    cin >> n; rep(i, 1, n) rep(j, 1, n + 1) cin >> a[i][j];
    int ret = guass(); if(ret == 1) rep(i, 1, n) cout << Dec(2) << res[i] << "\n";
    else if(ret == 0) cout << "No Solution";
    else cout << "No Solution";
}

三分

单峰/单谷函数求极值。每次取三等分点比较,丢掉不可能有答案的一段即可。

#define eps 1e-9
int n;
double l, r, a[N];
double f(double x){
    double sum = 0;
    for(int i = 1; i <= n + 1; i++) sum = sum * x + a[i];
    return sum;
}
void init(){
    cin >> n >> l >> r;
    for(int i = 1; i <= n + 1; i++) cin >> a[i];
    while(r - l > eps){
        double k = (r - l) / 3.0;
        double mid1 = l + k, mid2 = r - k;
        if(f(mid1) > f(mid2)) r = mid2;
        else l = mid1;
    }
    cout << Dec(5) << l;
}

线性筛

欧拉筛

int n, q, k[N];
vector<int> p;
int fp[N];
void init_p(int x){
	fp[0] = fp[1] = 0;
	for(int i = 2; i <= x; i++){
		if(!fp[i]){
			p.pb(i);
		}
		for(int j : p){
			if(i * j > x) break;
			fp[i * j] = 1;
			if(i % j == 0) break;
		}
	}
}
void init(){
    cin >> n >> q;
    init_p(n);
    while(q--){
        int k; cin >> k;
        cout << p[k - 1] << "\n";
    }
}

posted @ 2026-10-26 22:33  WangNoNo  阅读(13)  评论(0)    收藏  举报