算法全模板

柔情只为你懂 2022-09-12 04:43 135阅读 0赞

**逆序对的数量**

#include <bits/stdc++.h>
    
    typedef long long ll;
    using namespace std;
    
    const int N=100001;
    int q[N],tmp[N];
    
    ll merge_sort(int p[],int l,int r){
        
        if(l>=r) return 0;
        ll res;
        int mid=l+r>>1;
        res = merge_sort(q,l,mid)+merge_sort(q,mid+1,r);
    
        int i=l,j=mid+1,k=0;
    
        while(i<=mid&&j<=r){
        
            if(q[i]<=q[j]) tmp[k++]=q[i++];
            else tmp[k++]=q[j++],res+=mid-i+1;
        }
        while(i<=mid) tmp[k++]=q[i++];
        while(j<=r) tmp[k++]=q[j++];
        for(i=l,j=0;i<=r;j++,i++) q[i]=tmp[j];
        return res;
    }
    
    int main(){
        
        int n;
        cin>>n;
        for(int i=0;i<n;i++) scanf("%d",&q[i]);
    
        cout<<merge_sort(q,0,n-1)<<endl;
        return 0; 
    }

**二分**

bool check(int x) {
        /* ... */} // 检查x是否满足某种性质
    
    // 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
    int bsearch_1(int l, int r)
    {
        
        while (l < r)
        {
        
            int mid = l + r >> 1;
            if (check(mid)) r = mid;    // check()判断mid是否满足性质
            else l = mid + 1;
        }
        return l;
    }
    // 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
    int bsearch_2(int l, int r)
    {
        
        while (l < r)
        {
        
            int mid = l + r + 1 >> 1;
            if (check(mid)) l = mid;
            else r = mid - 1;
        }
        return l;
    }

**高精加**

vector<int> add(vector<int> &A, vector<int> &B)
    {
        
        if (A.size() < B.size()) return add(B, A);
    
        vector<int> C;
        int t = 0;
        for (int i = 0; i < A.size(); i ++ )
        {
        
            t += A[i];
            if (i < B.size()) t += B[i];
            C.push_back(t % 10);
            t /= 10;
        }
    
        if (t) C.push_back(t);
        return C;
    }

**高精减**

vector<int> sub(vector<int> &A, vector<int> &B)
    {
        
        vector<int> C;
        for (int i = 0, t = 0; i < A.size(); i ++ )
        {
        
            t = A[i] - t;
            if (i < B.size()) t -= B[i];
            C.push_back((t + 10) % 10);
            if (t < 0) t = 1;
            else t = 0;
        }
    
        while (C.size() > 1 && C.back() == 0) C.pop_back();
        return C;
    }

**高精乘**

vector<int> mul(vector<int> &A, int b)
    {
        
        vector<int> C;
    
        int t = 0;
        for (int i = 0; i < A.size() || t; i ++ )
        {
        
            if (i < A.size()) t += A[i] * b;
            C.push_back(t % 10);
            t /= 10;
        }
    
        while (C.size() > 1 && C.back() == 0) C.pop_back();
    
        return C;
    }

**高精除**

vector<int> div(vector<int> &A, int b, int &r)
    {
        
        vector<int> C;
        r = 0;
        for (int i = A.size() - 1; i >= 0; i -- )
        {
        
            r = r * 10 + A[i];
            C.push_back(r / b);
            r %= b;
        }
        reverse(C.begin(), C.end());
        while (C.size() > 1 && C.back() == 0) C.pop_back();
        return C;
    }

**差分**

//一维差分
    给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c
    //二维差分
    给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：
    S[x1, y1] += c, S[x2 + 1, y1] -= c, S[x1, y2 + 1] -= c, S[x2 + 1, y2 + 1] += c

**lowbit**

int lowbit(int x){
        
    	return x & -x;
    }

**离散化**

vector<int> alls; // 存储所有待离散化的值
    sort(alls.begin(), alls.end()); // 将所有值排序
    alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素
    
    // 二分求出x对应的离散化的值
    int find(int x) // 找到第一个大于等于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; // 映射到1, 2, ...n
    }

**区间合并**

// 将所有存在交集的区间合并
    void merge(vector<PII> &segs)
    {
        
        vector<PII> res;
    
        sort(segs.begin(), segs.end());
    
        int st = -2e9, ed = -2e9;
        for (auto seg : segs)
            if (ed < seg.first)
            {
        
                if (st != -2e9) res.push_back({
        st, ed});
                st = seg.first, ed = seg.second;
            }
            else ed = max(ed, seg.second);
    
        if (st != -2e9) res.push_back({
        st, ed});
    
        segs = res;
    }

**单调栈**

常见模型：找出每个数左边离它最近的比它大/小的数
    int tt = 0;
    for (int i = 1; i <= n; i ++ )
    {
        
        while (tt && check(stk[tt], i)) tt -- ;
        stk[ ++ tt] = i;
    }

**单调队列**

常见模型：找出滑动窗口中的最大值/最小值
    int hh = 0, tt = -1;
    for (int i = 0; i < n; i ++ )
    {
        
        while (hh <= tt && check_out(q[hh])) hh ++ ;  // 判断队头是否滑出窗口
        while (hh <= tt && check(q[tt], i)) tt -- ;
        q[ ++ tt] = i;
    }

**kmp**

// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
    求模式串的Next数组：
    for (int i = 2, j = 0; i <= m; i ++ )
    {
        
        while (j && p[i] != p[j + 1]) j = ne[j];
        if (p[i] == p[j + 1]) j ++ ;
        ne[i] = j;
    }
    
    // 匹配
    for (int i = 1, j = 0; i <= n; i ++ )
    {
        
        while (j && s[i] != p[j + 1]) j = ne[j];
        if (s[i] == p[j + 1]) j ++ ;
        if (j == m)
        {
        
            j = ne[j];
            // 匹配成功后的逻辑
        }
    }

**Trie**

int son[N][26], cnt[N], idx;
    // 0号点既是根节点，又是空节点
    // son[][]存储树中每个节点的子节点
    // cnt[]存储以每个节点结尾的单词数量
    
    // 插入一个字符串
    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];
    }

**并查集**

(1)朴素并查集：
    
        int p[N]; //存储每个点的祖宗节点
    
        // 返回x的祖宗节点
        int find(int x)
        {
        
            if (p[x] != x) p[x] = find(p[x]);
            return p[x];
        }
    
        // 初始化，假定节点编号是1~n
        for (int i = 1; i <= n; i ++ ) p[i] = i;
    
        // 合并a和b所在的两个集合：
        p[find(a)] = find(b);
    
    
    (2)维护size的并查集：
    
        int p[N], size[N];
        //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
    
        // 返回x的祖宗节点
        int find(int x)
        {
        
            if (p[x] != x) p[x] = find(p[x]);
            return p[x];
        }
    
        // 初始化，假定节点编号是1~n
        for (int i = 1; i <= n; i ++ )
        {
        
            p[i] = i;
            size[i] = 1;
        }
    
        // 合并a和b所在的两个集合：
        size[find(b)] += size[find(a)];
        p[find(a)] = find(b);
    
    
    (3)维护到祖宗节点距离的并查集：
    
        int p[N], d[N];
        //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离
    
        // 返回x的祖宗节点
        int find(int x)
        {
        
            if (p[x] != x)
            {
        
                int u = find(p[x]);
                d[x] += d[p[x]];
                p[x] = u;
            }
            return p[x];
        }
    
        // 初始化，假定节点编号是1~n
        for (int i = 1; i <= n; i ++ )
        {
        
            p[i] = i;
            d[i] = 0;
        }
    
        // 合并a和b所在的两个集合：
        p[find(a)] = find(b);
        d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量

**字符串哈希**

核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
    小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果
    
    typedef unsigned long long ULL;
    ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64
    
    // 初始化
    p[0] = 1;
    for (int i = 1; i <= n; i ++ )
    {
        
        h[i] = h[i - 1] * P + str[i];
        p[i] = p[i - 1] * P;
    }
    
    // 计算子串 str[l ~ r] 的哈希值
    ULL get(int l, int r)
    {
        
        return h[r] - h[l - 1] * p[r - l + 1];
    }

**bitset**

bitset, 圧位
        bitset<10000> s;
        ~, &, |, ^
        >>, <<
        ==, !=
        []
    
        count()  返回有多少个1
    
        any()  判断是否至少有一个1
        none()  判断是否全为0
    
        set()  把所有位置成1
        set(k, v)  将第k位变成v
        reset()  把所有位变成0
        flip()  等价于~
        flip(k) 把第k位取反

**邻接表**

// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
    int h[N], e[N], ne[N], idx;
    
    // 添加一条边a->b
    void add(int a, int b)
    {
        
        e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
    }
    
    // 初始化
    idx = 0;
    memset(h, -1, sizeof h);

**拓扑排序**

bool topsort()
    {
        
        int hh = 0, tt = -1;
    
        // d[i] 存储点i的入度
        for (int i = 1; i <= n; i ++ )
            if (!d[i])
                q[ ++ tt] = i;
    
        while (hh <= tt)
        {
        
            int t = q[hh ++ ];
    
            for (int i = h[t]; i != -1; i = ne[i])
            {
        
                int j = e[i];
                if (-- d[j] == 0)
                    q[ ++ tt] = j;
            }
        }
    
        // 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
        return tt == n - 1;
    }

**朴素dijkstra**

int g[N][N];  // 存储每条边
    int dist[N];  // 存储1号点到每个点的最短距离
    bool st[N];   // 存储每个点的最短路是否已经确定
    
    // 求1号点到n号点的最短路，如果不存在则返回-1
    int dijkstra()
    {
        
        memset(dist, 0x3f, sizeof dist);
        dist[1] = 0;
    
        for (int i = 0; i < n - 1; i ++ )
        {
        
            int t = -1;     // 在还未确定最短路的点中，寻找距离最小的点
            for (int j = 1; j <= n; j ++ )
                if (!st[j] && (t == -1 || dist[t] > dist[j]))
                    t = j;
    
            // 用t更新其他点的距离
            for (int j = 1; j <= n; j ++ )
                dist[j] = min(dist[j], dist[t] + g[t][j]);
    
            st[t] = true;
        }
    
        if (dist[n] == 0x3f3f3f3f) return -1;
        return dist[n];
    }

**堆优化dijkstra**

typedef pair<int, int> PII;
    
    int n;      // 点的数量
    int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
    int dist[N];        // 存储所有点到1号点的距离
    bool st[N];     // 存储每个点的最短距离是否已确定
    
    // 求1号点到n号点的最短距离，如果不存在，则返回-1
    int dijkstra()
    {
        
        memset(dist, 0x3f, sizeof dist);
        dist[1] = 0;
        priority_queue<PII, vector<PII>, greater<PII>> heap;
        heap.push({
        0, 1});      // first存储距离，second存储节点编号
    
        while (heap.size())
        {
        
            auto t = heap.top();
            heap.pop();
    
            int ver = t.second, distance = t.first;
    
            if (st[ver]) continue;
            st[ver] = true;
    
            for (int i = h[ver]; i != -1; i = ne[i])
            {
        
                int j = e[i];
                if (dist[j] > distance + w[i])
                {
        
                    dist[j] = distance + w[i];
                    heap.push({
        dist[j], j});
                }
            }
        }
    
        if (dist[n] == 0x3f3f3f3f) return -1;
        return dist[n];
    }

**Bellman-Ford**

int n, m;       // n表示点数，m表示边数
    int dist[N];        // dist[x]存储1到x的最短路距离
    
    struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
    {
        
        int a, b, w;
    }edges[M];
    
    // 求1到n的最短路距离，如果无法从1走到n，则返回-1。
    int bellman_ford()
    {
        
        memset(dist, 0x3f, sizeof dist);
        dist[1] = 0;
    
        // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
        for (int i = 0; i < n; i ++ )
        {
        
            for (int j = 0; j < m; j ++ )
            {
        
                int a = edges[j].a, b = edges[j].b, w = edges[j].w;
                if (dist[b] > dist[a] + w)
                    dist[b] = dist[a] + w;
            }
        }
    
        if (dist[n] > 0x3f3f3f3f / 2) return -1;
        return dist[n];
    }

**spfa**

int n;      // 总点数
    int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
    int dist[N];        // 存储每个点到1号点的最短距离
    bool st[N];     // 存储每个点是否在队列中
    
    // 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
    int spfa()
    {
        
        memset(dist, 0x3f, sizeof dist);
        dist[1] = 0;
    
        queue<int> q;
        q.push(1);
        st[1] = true;
    
        while (q.size())
        {
        
            auto t = q.front();
            q.pop();
    
            st[t] = false;
    
            for (int i = h[t]; i != -1; i = ne[i])
            {
        
                int j = e[i];
                if (dist[j] > dist[t] + w[i])
                {
        
                    dist[j] = dist[t] + w[i];
                    if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                    {
        
                        q.push(j);
                        st[j] = true;
                    }
                }
            }
        }
    
        if (dist[n] == 0x3f3f3f3f) return -1;
        return dist[n];
    }

**spfa判负环 o(nm)**

int n;      // 总点数
    int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
    int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
    bool st[N];     // 存储每个点是否在队列中
    
    // 如果存在负环，则返回true，否则返回false。
    bool spfa()
    {
        
        // 不需要初始化dist数组
        // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
    
        queue<int> q;
        for (int i = 1; i <= n; i ++ )
        {
        
            q.push(i);
            st[i] = true;
        }
    
        while (q.size())
        {
        
            auto t = q.front();
            q.pop();
    
            st[t] = false;
    
            for (int i = h[t]; i != -1; i = ne[i])
            {
        
                int j = e[i];
                if (dist[j] > dist[t] + w[i])
                {
        
                    dist[j] = dist[t] + w[i];
                    cnt[j] = cnt[t] + 1;
                    if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                    if (!st[j])
                    {
        
                        q.push(j);
                        st[j] = true;
                    }
                }
            }
        }
    
        return false;
    }

**floyd**

初始化：
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= n; j ++ )
                if (i == j) d[i][j] = 0;
                else d[i][j] = INF;
    
    // 算法结束后，d[a][b]表示a到b的最短距离
    void floyd()
    {
        
        for (int k = 1; k <= n; k ++ )
            for (int i = 1; i <= n; i ++ )
                for (int j = 1; j <= n; j ++ )
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
    }

**prim**

int n;      // n表示点数
    int g[N][N];        // 邻接矩阵，存储所有边
    int dist[N];        // 存储其他点到当前最小生成树的距离
    bool st[N];     // 存储每个点是否已经在生成树中
    
    
    // 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
    int prim()
    {
        
        memset(dist, 0x3f, sizeof dist);
    
        int res = 0;
        for (int i = 0; i < n; i ++ )
        {
        
            int t = -1;
            for (int j = 1; j <= n; j ++ )
                if (!st[j] && (t == -1 || dist[t] > dist[j]))
                    t = j;
    
            if (i && dist[t] == INF) return INF;
    
            if (i) res += dist[t];
            st[t] = true;
    
            for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
        }
    
        return res;
    }

**kruskal**

int n, m;       // n是点数，m是边数
    int p[N];       // 并查集的父节点数组
    
    struct Edge     // 存储边
    {
        
        int a, b, w;
    
        bool operator< (const Edge &W)const
        {
        
            return w < W.w;
        }
    }edges[M];
    
    int find(int x)     // 并查集核心操作
    {
        
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }
    
    int kruskal()
    {
        
        sort(edges, edges + m);
    
        for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集
    
        int res = 0, cnt = 0;
        for (int i = 0; i < m; i ++ )
        {
        
            int a = edges[i].a, b = edges[i].b, w = edges[i].w;
    
            a = find(a), b = find(b);
            if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
            {
        
                p[a] = b;
                res += w;
                cnt ++ ;
            }
        }
    
        if (cnt < n - 1) return INF;
        return res;
    }

**染色法判二分图**

int n;      // n表示点数
    int h[N], e[M], ne[M], idx;     // 邻接表存储图
    int color[N];       // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色
    
    // 参数：u表示当前节点，c表示当前点的颜色
    bool dfs(int u, int c)
    {
        
        color[u] = c;
        for (int i = h[u]; i != -1; i = ne[i])
        {
        
            int j = e[i];
            if (color[j] == -1)
            {
        
                if (!dfs(j, !c)) return false;
            }
            else if (color[j] == c) return false;
        }
    
        return true;
    }
    
    bool check()
    {
        
        memset(color, -1, sizeof color);
        bool flag = true;
        for (int i = 1; i <= n; i ++ )
            if (color[i] == -1)
                if (!dfs(i, 0))
                {
        
                    flag = false;
                    break;
                }
        return flag;
    }

**匈牙利算法**

int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
    int h[N], e[M], ne[M], idx;     // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
    int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
    bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过
    
    bool find(int x)
    {
        
        for (int i = h[x]; i != -1; i = ne[i])
        {
        
            int j = e[i];
            if (!st[j])
            {
        
                st[j] = true;
                if (match[j] == 0 || find(match[j]))
                {
        
                    match[j] = x;
                    return true;
                }
            }
        }
    
        return false;
    }
    
    // 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
    int res = 0;
    for (int i = 1; i <= n1; i ++ )
    {
        
        memset(st, false, sizeof st);
        if (find(i)) res ++ ;
    }

**试除法判质数**

bool is_prime(int x)
    {
        
        if (x < 2) return false;
        for (int i = 2; i <= x / i; i ++ )
            if (x % i == 0)
                return false;
        return true;
    }

**试除法分解质因数**

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

**线性筛**

int primes[N], cnt;     // primes[]存储所有素数
    bool st[N];         // st[x]存储x是否被筛掉
    
    void get_primes(int n)
    {
        
        for (int i = 2; i <= n; i ++ )
        {
        
            if (!st[i]) primes[cnt ++ ] = i;
            for (int j = 0; primes[j] <= n / i; j ++ )
            {
        
                st[primes[j] * i] = true;
                if (i % primes[j] == 0) break;
            }
        }
    }

**试除法求所有约数**

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

**约数个数和约数之和**

如果 N = p1^c1 * p2^c2 * ... *pk^ck
    约数个数： (c1 + 1) * (c2 + 1) * ... * (ck + 1)
    约数之和： (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)

**gcd和gbc**

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

**快速幂**

求 m^k mod p，时间复杂度 O(logk)。
    
    int qmi(int m, int k, int p)
    {
        
        int res = 1 % p, t = m;
        while (k)
        {
        
            if (k&1) res = res * t % p;
            t = t * t % p;
            k >>= 1;
        }
        return res;
    }

**exgcd**

// 求x, y，使得ax + by = gcd(a, b)
    int exgcd(int a, int b, int &x, int &y)
    {
        
        if (!b)
        {
        
            x = 1; y = 0;
            return a;
        }
        int d = exgcd(b, a % b, y, x);
        y -= (a/b) * x;
        return d;
    }

**高斯消元**

// a[N][N]是增广矩阵
    int gauss()
    {
        
        int c, r;
        for (c = 0, r = 0; c < n; c ++ )
        {
        
            int t = r;
            for (int i = r; i < n; i ++ )   // 找到绝对值最大的行
                if (fabs(a[i][c]) > fabs(a[t][c]))
                    t = i;
    
            if (fabs(a[t][c]) < eps) continue;
    
            for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);      // 将绝对值最大的行换到最顶端
            for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];      // 将当前行的首位变成1
            for (int i = r + 1; i < n; i ++ )       // 用当前行将下面所有的列消成0
                if (fabs(a[i][c]) > eps)
                    for (int j = n; j >= c; j -- )
                        a[i][j] -= a[r][j] * a[i][c];
    
            r ++ ;
        }
    
        if (r < n)
        {
        
            for (int i = r; i < n; i ++ )
                if (fabs(a[i][n]) > eps)
                    return 2; // 无解
            return 1; // 有无穷多组解
        }
    
        for (int i = n - 1; i >= 0; i -- )
            for (int j = i + 1; j < n; j ++ )
                a[i][n] -= a[i][j] * a[j][n];
    
        return 0; // 有唯一解
    }

**组合数**

1.递归法
    // c[a][b] 表示从a个苹果中选b个的方案数
    for (int i = 0; i < N; i ++ )
        for (int j = 0; j <= i; j ++ )
            if (!j) c[i][j] = 1;
            else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
    2.预处理逆元
    首先预处理出所有阶乘取模的余数fact[N]，以及所有阶乘取模的逆元infact[N]
    如果取模的数是质数，可以用费马小定理求逆元
    int qmi(int a, int k, int p)    // 快速幂模板
    {
        
        int res = 1;
        while (k)
        {
        
            if (k & 1) res = (LL)res * a % p;
            a = (LL)a * a % p;
            k >>= 1;
        }
        return res;
    }
    
    // 预处理阶乘的余数和阶乘逆元的余数
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i ++ )
    {
        
        fact[i] = (LL)fact[i - 1] * i % mod;
        infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
    }
    3.Lucas
    若p是质数，则对于任意整数 1 <= m <= n，有：
        C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)
    
    int qmi(int a, int k, int p)  // 快速幂模板
    {
        
        int res = 1 % p;
        while (k)
        {
        
            if (k & 1) res = (LL)res * a % p;
            a = (LL)a * a % p;
            k >>= 1;
        }
        return res;
    }
    
    int C(int a, int b, int p)  // 通过定理求组合数C(a, b)
    {
        
        if (a < b) return 0;
    
        LL x = 1, y = 1;  // x是分子，y是分母
        for (int i = a, j = 1; j <= b; i --, j ++ )
        {
        
            x = (LL)x * i % p;
            y = (LL) y * j % p;
        }
    
        return x * (LL)qmi(y, p - 2, p) % p;
    }
    
    int lucas(LL a, LL b, int p)
    {
        
        if (a < p && b < p) return C(a, b, p);
        return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
    }
    4.分解质因数
    当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
        1. 筛法求出范围内的所有质数
        2. 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中p的次数是 n / p + n / p^2 + n / p^3 + ...
        3. 用高精度乘法将所有质因子相乘
    
    int primes[N], cnt;     // 存储所有质数
    int sum[N];     // 存储每个质数的次数
    bool st[N];     // 存储每个数是否已被筛掉
    
    
    void get_primes(int n)      // 线性筛法求素数
    {
        
        for (int i = 2; i <= n; i ++ )
        {
        
            if (!st[i]) primes[cnt ++ ] = i;
            for (int j = 0; primes[j] <= n / i; j ++ )
            {
        
                st[primes[j] * i] = true;
                if (i % primes[j] == 0) break;
            }
        }
    }
    
    
    int get(int n, int p)       // 求n！中的次数
    {
        
        int res = 0;
        while (n)
        {
        
            res += n / p;
            n /= p;
        }
        return res;
    }
    
    
    vector<int> mul(vector<int> a, int b)       // 高精度乘低精度模板
    {
        
        vector<int> c;
        int t = 0;
        for (int i = 0; i < a.size(); i ++ )
        {
        
            t += a[i] * b;
            c.push_back(t % 10);
            t /= 10;
        }
    
        while (t)
        {
        
            c.push_back(t % 10);
            t /= 10;
        }
    
        return c;
    }
    
    get_primes(a);  // 预处理范围内的所有质数
    
    for (int i = 0; i < cnt; i ++ )     // 求每个质因数的次数
    {
        
        int p = primes[i];
        sum[i] = get(a, p) - get(b, p) - get(a - b, p);
    }
    
    vector<int> res;
    res.push_back(1);
    
    for (int i = 0; i < cnt; i ++ )     // 用高精度乘法将所有质因子相乘
        for (int j = 0; j < sum[i]; j ++ )
            res = mul(res, primes[i]);

**卡特兰数**

给定n个0和n个1，它们按照某种顺序排成长度为2n的序列，满足任意前缀中0的个数都不少于1的个数的序列的数量为： Cat(n) = C(2n, n) / (n + 1)

**二进制优化多重背包**

#include <bits/stdc++.h>
    using namespace std;
    
    const int N = 5e5;
    int f[N], v[N], w[N];
    int cnt = 1;
    
    int main(){
        
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;i++){
        
            int a,b,s;
            cin>>a>>b>>s;
            int k=1;
            while(k<s){
        
                v[cnt]=a*k;
                w[cnt++]=b*k;
                s-=k;
                k*=2;
            }
            if(s>0){
        
                v[cnt]=a*s;
                w[cnt++]=b*s;
            }
        }
        
        n=cnt;
        for(int i=1;i<=n;i++){
        
            for(int j=m;j>=v[i];j--){
        
                f[j]=max(f[j],f[j-v[i]]+w[i]);
            }
        }
        cout<<f[m];
        return 0;
    }

**二分优化LIS**

#include <bits/stdc++.h>
    using namespace std;
    const int N = 1e6+10,INF=2e9;
    int n;
    int a[N], q[N];
    
    int main()
    {
        
        cin>>n;
        for(int i=0;i<n;i++) cin>>a[i];
        int len=0;
        q[0]=-INF;
        for(int i=0;i<n;i++){
        
            int l=0,r=len;
            while(l<r){
        
                int mid=(l+r+1)>>1;
                if(q[mid]<a[i]) l=mid;
                else r=mid-1;
            }
            len=max(len,r+1);
            q[r+1]=a[i];
        }
        
        cout<<len;
        return 0;
    }

**LCS**

#include <bits/stdc++.h>
    using namespace std;
    const int N = 1010;
    int n,m;
    char a[N],b[N];
    int f[N][N];
    int main()
    {
        
        cin>>n>>m;
        cin>>a+1>>b+1;
        for(int i=1;i<=n;i++){
        
            for(int j=1;j<=m;j++){
        
                f[i][j]=max(f[i-1][j],f[i][j-1]);
                if(a[i]==b[j]) f[i][j]=max(f[i][j],f[i-1][j-1]+1);
            }
        }
        int res=0;
        for(int i=1;i<=n;i++){
        
            for(int j=1;j<=m;j++){
        
                res=max(res,f[i][j]);
            }
        }
        cout<<res;
    }

**最短编辑距离**

#include <bits/stdc++.h>
    using namespace std;
    
    const int N = 1010;
    char a[N],b[N];
    int n,m;
    int f[N][N];
    
    int main()
    {
        
        cin>>n>>a+1>>m>>b+1;
        for(int i=0;i<=m;i++) f[0][i]=i;
        for(int i=0;i<=n;i++){
        
            f[i][0]=i;
        }
        
        for(int i=1;i<=n;i++){
        
            for(int j=1;j<=m;j++){
        
                f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
                if(a[i]==b[j]) f[i][j]=min(f[i][j],f[i-1][j-1]);
                else f[i][j]=min(f[i][j],f[i-1][j-1]+1);
            }
        }
        cout<<f[n][m];
        return 0;
    }

**编辑距离**

给定 n 个长度不超过 10 的字符串以及 m 次询问，每次询问给出一个字符串和一个操作次数上限。
    
    对于每次询问，请你求出给定的 n 个字符串中有多少个字符串可以在上限操作次数内经过操作变成询问给出的字符串。
    
    每个对字符串进行的单个字符的插入、删除或替换算作一次操作。
    #include <bits/stdc++.h>
    using namespace std;
    
    const int N = 15,M=1010;
    
    int n,m;
    int f[N][N];
    char str[M][N];
    
    int edit_distance(char a[],char b[]){
        
        int la=strlen(a+1),lb=strlen(b+1);
        for(int i=0;i<=lb;i++) f[0][i]=i;
        for(int i=0;i<=la;i++) f[i][0]=i;
        for(int i=1;i<=la;i++){
        
            for(int j=1;j<=lb;j++){
        
                f[i][j]=min(f[i-1][j]+1,f[i][j-1]+1);
                f[i][j]=min(f[i][j],f[i-1][j-1]+(a[i]!=b[j]));
            }
        }
        return f[la][lb];
    }
    
    
    int main()
    {
        
        cin>>n>>m;
        for(int i=0;i<n;i++) cin>>str[i]+1;
        
        while (m -- ){
        
            char s[N];
            int limit;
            cin>>s+1>>limit;
            
            int res=0;
            for(int i=0;i<n;i++){
        
                if(edit_distance(str[i],s)<=limit) res++;
            }
            cout<<res<<endl;
        }
        return 0;
    }

**石子合并**

#include <bits/stdc++.h>
    using namespace std;
    
    const int N = 310,INF=1e9;
    
    int n;
    int f[N][N];
    int s[N];
    
    int main()
    {
        
        cin>>n;
        for(int i=1;i<=n;i++) cin>>s[i];
        
        for (int i = 1; i <= n; i ++ ) s[i]+=s[i-1];
        
        for (int i = 1; i <= n; i ++ ){
        
            for (int j = 1; j <= n; j ++ ){
        
                if(i==j) f[i][j]=0;
                else f[i][j]=INF;
            }
        }
        
        for(int len=2;len<=n;len++){
        
            for(int i=1;i+len-1<=n;i++){
        
                int l=i,r=i+len-1;
                // f[l][r]=INF;
                for(int k=i;k<r;k++){
        
                    f[l][r]=min(f[l][r],f[l][k]+f[k+1][r]+s[r]-s[l-1]);
                } 
            }
        }
        cout<<f[1][n];
    }

**蒙德里安的梦想**

求把 N×M 的棋盘分割成若干个 1×2 的的长方形，有多少种方案。
    #include <bits/stdc++.h>
    using namespace std;
    typedef long long LL;
    const double eps = 1e-8;
    const int N = 12, M = 1 << N;
    
    int n, m;
    LL f[N][M];
    vector<int> state[M];
    bool st[N];
    
    void solve(){
        
        for(int i = 0 ; i < 1 << n; i ++ ){
        
            int cnt = 0;
            bool flag = true;
            for(int j = 0; j < n; j ++ ){
        
                if((i >> j) & 1){
        
                    if(cnt & 1){
        
                        flag = false;
                        break;
                    }
                    cnt = 0;
                }
                else cnt ++ ;
            }
            if(cnt & 1) flag = false;
            st[i] = flag;
        }
        for(int i = 0 ; i < 1 << n; i ++ ){
        
            state[i].clear();
            for(int j = 0; j < 1 << n; j ++ ){
        
                if(!(i & j) && st[i | j])
                    state[i].push_back(j);
            }
        }
        memset(f, 0, sizeof f);
        f[0][0] = 1;
        for(int i = 1; i <= m; i ++ ){
        
            for(int j = 0 ; j < 1 << n; j ++ ){
        
                for(int k = 0; k < state[j].size(); k ++ ){
        
                    int x = state[j][k];
                    f[i][j] += f[i - 1][x];
                }
            }
        }
        printf("%lld\n", f[m][0]);
    }
    
    int main(){
        
        while(cin >> n >> m, n || m){
        
            solve();
        }
        return 0;
    }

**最短哈密顿路**

#include <bits/stdc++.h>
    using namespace std;
    
    const int N = 20,M=1<<N;
    int a[N][N];
    int f[M][N];
    int n;
    
    int main()
    {
        
        cin>>n;
        for(int i=0;i<n;i++)
            for(int j=0;j<n;j++)
                cin>>a[i][j];
            
        memset(f,0x3f,sizeof f);
        f[1][0]=0;
        
        for(int i=0;i<1<<n;i++)
            for(int j = 0;j<n;j++)
                if(i>>j&1)
                    for(int k=0;k<n;k++)
                        if((i-(1<<j))>>k&1)
                            f[i][j]=min(f[i][j],f[i-(1<<j)][k]+a[k][j]);
        cout<<f[(1<<n)-1][n-1]<<endl;
        return 0;
        
    }

**滑雪**

#include <bits/stdc++.h>
    using namespace std;
    
    const int N = 310;
    int f[N][N],w[N][N];
    int n,m;
    int dx[4] = {
        -1, 0, 1, 0}, dy[4] = {
        0, 1, 0, -1};
    
    int dp(int x,int y){
        
        int &v=f[x][y];
        if(v!=-1) return v;
        v=1;
        for(int i=0;i<4;i++){
        
            int a=x+dx[i],b=y+dy[i];
            if(a>=1&&a<=n&&b>=1&&b<=m&&w[a][b]<w[x][y])
                v=max(v,dp(a,b)+1);
            
        }
        return v;
    }
    
    int main()
    {
        
        cin>>n>>m;
        for (int i = 1; i <=n; i ++ )
            for (int j = 1; j <=m; j ++ ) cin>>w[i][j];
        
        memset(f,-1,sizeof f);
        int res=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                res=max(res,dp(i,j));
        cout<<res;
        return 0;
    }