v1.0.5:增加了后缀数组和其他若干算法、修改了部分错误

Author: lr580

README.md

@@ -1,4 +1,4 @@
-**当前最新普通版发布版本为 `v1.0.4`** ，  **最新打印版发布版本为 `v1.0.0` (总词数约7.7w(含代码))**
+**当前最新普通版发布版本为 `v1.0.5`** ，  **最新打印版发布版本为 `v1.0.0` (总词数约7.7w(含代码))**
 
 成品为 `template.pdf` (移步 [releases](https://github.com/lr580/algorithm_template/releases) 查看/下载)
 
@@ -46,17 +46,32 @@
 
 ## 更新日志
 
+- 22/09/01 - 22/10/18 (`v1.0.5`)
+
+  - 添加了边双连通分量例题
+  
+  - 添加了可撤销并查集+线段树分治动态判二分图的例题
+  - 修改了 manacher 一处错误
+  - 修改了数论基础同余的一处书写错误
+  - 添加了封装的最小费用最大流模板
+  - 添加了后缀数组内容
+  - 添加了 STL 重载 unordered\_set 内容
+  - 添加了 pollard\_rho 算法
+  - 添加了斐波那契数列模数循环节结论
+  - 添加了线性快速幂
+  - 添加了差分约束算法
+  
 - 22/06/10 - 22/08/27 (`v1.0.4`)
 
   - 微改了 STL 的  nth\_element 和 inplace\_merge
-  
+
   - 微改了复杂度一节的排版错误
   - 删除了 STL 的 string 重复内容
   - 添加了多项式一节，增加 NTT 和分治 FFT 内容
   - 修正了线段树区间最值例题表述错误
   - 更换了欧拉筛一道例题
   - 添加了 tarjan 算法求点双连通分量和圆方树内容
-  
+
 - 22/05/17 - 22/05/25 (`v1.0.3`)
 
   - 增加了stringstream

code/cf813f_segtree_partition.cpp

@@ -0,0 +1,162 @@
+#include <bits/stdc++.h>
+const int N = 200000 + 10;
+int n, m, ans[N];
+struct E
+{
+    int u, v;
+    E(int a, int b) : u(a), v(b) {}
+};
+std::map<int, int> g[N];
+
+int L[N << 2], R[N << 2];
+std::vector<E> tag[N << 2];
+#define lc (o << 1)
+#define rc ((o << 1) | 1)
+void build(int o, int l, int r)
+{
+    L[o] = l;
+    R[o] = r;
+    if (l == r)
+        return;
+    int mid = (l + r) >> 1;
+    build(lc, l, mid);
+    build(rc, mid + 1, r);
+}
+// 把一条边拆到logm个区间上去.
+// 可以说线段树只是用来保证复杂度的...
+void query(int o, int l, int r, const E &e)
+{
+    if (L[o] > r || R[o] < l)
+        return;
+    if (l <= L[o] && R[o] <= r)
+    {
+        tag[o].push_back(e);
+        return;
+    }
+    query(lc, l, r, e);
+    query(rc, l, r, e);
+}
+
+// merged tree(root=x)->tree(root=y)
+struct P
+{
+    int x, y;
+    P(int a, int b) : x(a), y(b) {}
+};
+int fa[N], size[N], dis[N];
+inline int getpar(int x)
+{
+    while (fa[x] != x)
+        x = fa[x];
+    return x;
+}
+
+// 到并查集根所经过的边数mod2.
+// mod2意义下的加法即为xor.
+// 用来查询x和根是不是相同颜色.
+inline int getdis(int x)
+{
+    int d = 0;
+    while (fa[x] != x)
+    {
+        d ^= dis[x];
+        x = fa[x];
+    }
+    return d;
+}
+/// 按照size合并.
+inline int solve(int x, int y, std::stack<P> &stk)
+{
+    int dx = getdis(x), dy = getdis(y);
+    x = getpar(x);
+    y = getpar(y);
+    if (x == y)
+        return (dx ^ dy);
+    if (size[x] > size[y])
+    {
+        std::swap(x, y);
+        std::swap(dx, dy);
+    }
+    size[y] += size[x];
+    fa[x] = y;
+    dis[x] = (dx ^ dy ^ 1);
+    stk.push(P(x, y));
+    return 1;
+}
+// 撤销(x->y)的合并.拆出来,size改回去.dis改成0
+inline void back(P p)
+{
+    int x = p.x, y = p.y;
+    size[y] -= size[x];
+    dis[fa[x] = x] = 0;
+}
+// 递归线段树,进入区间[l,r]时
+// 保证时间轴上[l,r]范围内一直可用的边都被加入了
+void dfs(int o, int flag)
+{
+    std::stack<P> stk;
+    for (auto e : tag[o])
+        flag &= solve(e.u, e.v, stk);
+    if (L[o] == R[o])
+        ans[L[o]] = flag;
+    else
+    {
+        dfs(lc, flag);
+        dfs(rc, flag);
+    }
+    // 撤销操作...不然从爸爸进入兄弟节点的时候开始讲到的那个性质会被破坏.
+    // 注意撤销顺序...
+    while (!stk.empty())
+    {
+        back(stk.top());
+        stk.pop();
+    }
+}
+
+int read()
+{
+    int x = 0;
+    char c;
+    do
+    {
+        c = getchar();
+    } while (!isdigit(c));
+    do
+    {
+        x = x * 10 + c - '0';
+        c = getchar();
+    } while (isdigit(c));
+    return x;
+}
+int main()
+{
+    n = read();
+    m = read();
+    build(1, 1, m);
+    int x, y;
+    for (int i = 1; i <= m; i++)
+    {
+        x = read();
+        y = read();
+        if (x > y)
+            std::swap(x, y);
+        if (g[x][y] == 0)
+            g[x][y] = i;
+        else
+        {
+            query(1, g[x][y], i - 1, E(x, y));
+            g[x][y] = 0;
+        }
+    }
+    for (int i = 1; i <= n; i++)
+    {
+        size[fa[i] = i] = 1;
+        for (auto p : g[i])
+            if (p.second > 0)
+                query(1, p.second, m, E(i, p.first));
+    }
+    dfs(1, 1);
+    for (int i = 1; i <= m; i++)
+        puts(ans[i] ? "YES" : "NO");
+    return 0;
+}

code/min_cost_max_flow.cpp

@@ -0,0 +1,150 @@
+#include <bits/stdc++.h>
+using namespace std;
+using ll = long long;
+
+template <const int mn, class ty = int>
+struct MinCostMaxFlow
+{
+    const ty inf = numeric_limits<ty>::max();
+    struct edge
+    {
+        int v;
+        ty cap, cost;
+        int rev;
+    };
+    vector<edge> g[mn];
+    ty sum{}, dis[mn]{};
+    int n, s, t, aug[mn]{};
+    ty flow{}, cost{};
+    bool augment()
+    {
+        fill(dis, dis + n + 1, inf);
+        priority_queue<pair<int, int>> q;
+        dis[t] = 0;
+        q.push({dis[t], t});
+        for (int u, v; !q.empty() && q.top().first != inf;)
+        {
+            u = q.top().second;
+            q.pop();
+            for (auto e : g[u])
+            {
+                v = e.v;
+                if (g[v][e.rev].cap && dis[v] > dis[u] - e.cost)
+                {
+                    dis[v] = dis[u] - e.cost;
+                    q.push({dis[v], v});
+                }
+            }
+        }
+        sum += dis[s];
+        for (int u = 1; u <= n; ++u)
+        {
+            for (auto &e : g[u])
+            {
+                e.cost += dis[e.v] - dis[u];
+            }
+        }
+        return dis[s] != inf;
+    }
+
+    ty dfs(int u, ty lim)
+    {
+        if (u == t)
+        {
+            cost += lim * sum;
+            return lim;
+        }
+        ty f = 0;
+        aug[u] = 1;
+        for (auto &e : g[u])
+        {
+            int v = e.v;
+            if (!e.cost && e.cap && !aug[v])
+            {
+                ty t = dfs(v, min(lim - f, e.cap));
+                e.cap -= t;
+                g[v][e.rev].cap += t;
+                f += t;
+                if (f == lim)
+                {
+                    break;
+                }
+            }
+        }
+        if (f == lim)
+        {
+            aug[u] = 0;
+        }
+        return f;
+    }
+
+    void add(int u, int v, ty cap, ty cost)
+    {
+        g[u].push_back({v, cap, cost, (int)g[v].size()});
+        g[v].push_back({u, 0, -cost, (int)g[u].size() - 1});
+    }
+
+    pair<ty, ty> solve(int _n, int _s, int _t)
+    {
+        n = _n, s = _s, t = _t, flow = cost = 0;
+        do
+        {
+            ty f;
+            do
+            {
+                memset(aug, 0, (n + 1) << 2);
+                f = dfs(s, inf);
+                flow += f;
+            } while (f > 0);
+        } while (augment());
+        return {flow, cost};
+    }
+};
+
+const ll mn = 405;
+MinCostMaxFlow<mn * 2, int> d;
+signed main()
+{
+    cin.tie(0)->ios::sync_with_stdio(false);
+    int n, m;
+    char a[mn];
+    cin >> n >> m;
+    int s = n + m + 1, t = s + 1;
+    for (ll i = 1; i <= n; ++i)
+    {
+        cin >> (a + 1);
+        d.add(s, i, 1, 0);
+        for (ll j = 1; j <= m; ++j)
+        {
+            if (a[j] == '1')
+            {
+                d.add(i, n + j, 1, 0);
+            }
+        }
+    }
+    for (ll i = 1; i <= m; ++i)
+    {
+        for (ll j = 1; j <= n; ++j)
+        {
+            d.add(n + i, t, 1, j);
+        }
+    }
+    auto f = d.solve(t, s, t);
+    if (f.first != n)
+    {
+        cout << -1;
+        return 0;
+    }
+    for (ll i = 1; i <= n; ++i)
+    {
+        for (auto e : d.g[i])
+        {
+            if (!e.cap && e.v > n)
+            {
+                cout << (e.v - n) << ' ';
+                break;
+            }
+        }
+    }
+    return 0;
+}