{"id":154,"date":"2025-12-29T09:26:54","date_gmt":"2025-12-29T01:26:54","guid":{"rendered":"https:\/\/jiangqvweihuan.cn\/?p=154"},"modified":"2026-04-26T20:02:41","modified_gmt":"2026-04-26T12:02:41","slug":"%e7%ae%97%e6%b3%95%e5%bf%83%e4%bc%a0%c2%b7%e7%ab%9e%e8%b5%9b%e6%a8%a1%e6%9d%bf","status":"publish","type":"post","link":"https:\/\/jiangqvweihuan.cn\/index.php\/2025\/12\/29\/%e7%ae%97%e6%b3%95%e5%bf%83%e4%bc%a0%c2%b7%e7%ab%9e%e8%b5%9b%e6%a8%a1%e6%9d%bf\/","title":{"rendered":"\u7b97\u6cd5\u5fc3\u4f20\u00b7\u7ade\u8d5b\u6a21\u677f"},"content":{"rendered":"\n

Simplicity is the ultimate form of sophistication<\/strong><\/p>Leonardo da Vinci<\/strong><\/cite><\/blockquote><\/figure>\n\n\n\n

\u5728\u7b97\u6cd5\u7ade\u8d5b\u7684\u9053\u8def\u4e0a\uff0c\u4e00\u5957\u53ef\u9760\u3001\u9ad8\u6548\u7684\u4ee3\u7801\u6a21\u677f\u80fd\u4e3a\u6211\u4eec\u8282\u7701\u5b9d\u8d35\u7684\u65f6\u95f4\uff0c\u8ba9\u6211\u4eec\u66f4\u4e13\u6ce8\u4e8e\u95ee\u9898\u672c\u8eab\u7684\u903b\u8f91\u3002\u4ee5\u4e0b\u662f\u6211\u5728\u5b66\u4e60\u548c\u5b9e\u8df5\u4e2d\uff0c\u53c2\u8003\u591a\u4f4d\u4f18\u79c0\u9009\u624b\u7684\u4ee3\u7801\u98ce\u683c\u4e0e\u4f18\u5316\u6280\u5de7\u540e\uff0c\u6574\u7406\u51fa\u7684\u4e00\u5957\u5b9e\u7528\u6a21\u677f\u3002\u5b83\u5305\u542b\u4e86\u7ade\u8d5b\u4e2d\u6700\u5e38\u7528\u7684\u8bbe\u7f6e\u4e0e\u5de5\u5177\u51fd\u6570\uff0c\u5e0c\u671b\u80fd\u4e3a\u4f60\u7684\u8bad\u7ec3\u548c\u6bd4\u8d5b\u63d0\u4f9b\u4e00\u4efd\u624e\u5b9e\u7684\u8d77\u70b9\u3002<\/p>\n\n\n\n

#include <bits\/stdc++.h>\n#define endl '\\n'\nusing namespace std;\nusing ll = long long;\n\/\/ \u4f18\u70b9\uff1a\u907f\u514d std::endl \u7684\u7f13\u51b2\u533a\u5237\u65b0\uff0c\u63d0\u5347\u8f93\u51fa\u6027\u80fd\n\/\/ \u4f7f\u7528\u6761\u4ef6\uff1a\u786e\u4fdd\u4ee3\u7801\u4e2d\u4e0d\u4f7f\u7528 std::endl\uff0c\u4e14\u4e0d\u9700\u8981\u7acb\u5373\u5237\u65b0\u7f13\u51b2\u533a\n\n\/\/ ====================== \u5e38\u7528\u5e38\u91cf\u5b9a\u4e49 ======================\nconst int MOD = 1e9 + 7;                       \/\/ \u6807\u51c6\u6a21\u6570\uff0c\u9002\u7528\u4e8e\u5927\u591a\u6570\u53d6\u6a21\u8fd0\u7b97\nconst double PI = acos(-1.0);                  \/\/ \u5706\u5468\u7387\u5e38\u91cf\uff0c\u51e0\u4f55\u8ba1\u7b97\u65f6\u4f7f\u7528\nconst double eps = 1e-8;                       \/\/ \u6d6e\u70b9\u6570\u6bd4\u8f83\u5bb9\u5dee\uff0c\u7528\u4e8e\u5224\u65ad\u76f8\u7b49\nconst int dx[8] = {-1, 1, 0, 0, -1, -1, 1, 1}; \/\/ \u65b9\u5411\u6570\u7ec4\nconst int dy[8] = {0, 0, -1, 1, -1, 1, -1, 1}; \/\/ \u4e0a\u3001\u4e0b\u3001\u5de6\u3001\u53f3 + \u5bf9\u89d2\u7ebf\n\n\/\/ ====================== \u6570\u8bba\u57fa\u7840 ======================\nll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } \/\/ \u6b27\u51e0\u91cc\u5f97\u7b97\u6cd5\n\nll lcm(ll a, ll b) { return a \/ gcd(a, b) * b; } \/\/ a * b = gcd(a, b) * lcm(a, b)\n\nll mul(ll a, ll b, ll mod)\n{\n    \/\/ \u9632\u6b62\u6ea2\u51fa\u7684\u4e58\u6cd5\uff0c\u4f7f\u7528\u5feb\u901f\u52a0\u6216 __int128\uff08\u82e5\u73af\u5883\u652f\u6301\uff09\n    \/\/ \u4f7f\u7528\u65b9\u6cd5\uff1amul(a, b, mod) \u8fd4\u56de (a*b)%mod\n    \/\/ return (ll)((__int128)a * b % mod);  \/\/ \u73af\u5883\u5141\u8bb8\u9009\u62e9\u8fd9\u4e00\u6761\u8bed\u53e5\n    a %= mod;\n    b %= mod;\n    ll res = 0;\n    while (b > 0)\n    {\n        if (b & 1) res = (res + a) % mod;\n        a = (a + a) % mod;\n        b >>= 1;\n    }\n    return res;\n}\n\nll qpow(ll a, ll b, ll mod)\n{\n    \/\/ \u5feb\u901f\u5e42\uff0c\u8fd4\u56de a^b % mod\n    ll res = 1;\n    a %= mod;\n    while (b)\n    {\n        if (b & 1) res = mul(res, a, mod);\n        a = mul(a, a, mod);\n        b >>= 1;\n    }\n    return res;\n}\n\n\/\/ Miller-Rabin \u7d20\u6570\u6d4b\u8bd5\nbool witness(ll a, ll n)\n{\n    ll u = n - 1;\n    int t = 0;\n    while ((u & 1) == 0) { u >>= 1; t++; }\n    ll x1 = qpow(a, u, n);\n    ll x2;\n    for (int i = 1; i <= t; ++i)\n    {\n        x2 = mul(x1, x1, n);\n        if (x2 == 1 && x1 != 1 && x1 != n - 1) return true;\n        x1 = x2;\n    }\n    if (x1 != 1) return true;\n    return false;\n}\n\nbool miller_rabin(ll n)\n{\n    \/\/ \u5224\u65ad n \u662f\u5426\u4e3a\u7d20\u6570\uff08\u6982\u7387\u6027\uff0cs=50 \u6b21\u6d4b\u8bd5\uff09\n    int s = 50;\n    if (n < 2) return false;\n    if (n == 2) return true;\n    if (n % 2 == 0) return false;\n    for (int i = 0; i < s; ++i)\n    {\n        ll a = rand() % (n - 1) + 1;\n        if (witness(a, n)) return false;\n    }\n    return true;\n}\n\nvector<ll> euler_sieve(ll n)\n{\n    \/\/ \u6b27\u62c9\u7ebf\u6027\u7b5b\uff0c\u8fd4\u56de [2, n] \u5185\u6240\u6709\u7d20\u6570\n    vector<bool> vis(n + 1, true);\n    vector<ll> prime;\n    for (ll i = 2; i <= n; ++i)\n    {\n        if (vis[i]) prime.push_back(i);\n        for (ll j = 0; j < (ll)prime.size(); ++j)\n        {\n            if (i > n \/ prime[j]) break;\n            vis[i * prime[j]] = false;\n            if (i % prime[j] == 0) break;\n        }\n    }\n    return prime;\n}\n\n\/\/ ====================== \u6570\u8bba\u8fdb\u9636 ======================\n\n\/\/ \u6269\u5c55\u6b27\u51e0\u91cc\u5f97\u7b97\u6cd5\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1aexgcd(a,b,x,y) \u8fd4\u56de gcd(a,b)\uff0c\u5e76\u5f97\u5230\u4e00\u7ec4\u89e3 x,y \u6ee1\u8db3 a*x + b*y = gcd(a,b)\nll exgcd(ll a, ll b, ll &x, ll &y)\n{\n    if (b == 0) { x = 1; y = 0; return a; }\n    ll d = exgcd(b, a % b, y, x);\n    y -= a \/ b * x;\n    return d;\n}\n\n\/\/ \u4e2d\u56fd\u5269\u4f59\u5b9a\u7406\uff08\u6a21\u6570\u4e92\u8d28\uff09\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1acrt(mod, rem) \u8fd4\u56de\u6700\u5c0f\u975e\u8d1f\u89e3 x\uff0c\u6ee1\u8db3 x \u2261 rem[i] (mod mod[i])\uff0c\u6a21\u6570\u4e24\u4e24\u4e92\u8d28\nll crt(const vector<ll>& mod, const vector<ll>& rem)\n{\n    ll M = 1, ans = 0;\n    for (ll m : mod) M *= m;\n    for (size_t i = 0; i < mod.size(); ++i)\n    {\n        ll Mi = M \/ mod[i];\n        ll inv, y;\n        exgcd(Mi, mod[i], inv, y);\n        inv = (inv % mod[i] + mod[i]) % mod[i];\n        ans = (ans + rem[i] * Mi % M * inv % M) % M;\n    }\n    return ans;\n}\n\n\/\/ \u7ec4\u5408\u6570\u9884\u5904\u7406\uff08\u9636\u4e58+\u9006\u5143\uff0cMOD \u9700\u4e3a\u7d20\u6570\uff09\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1a\u58f0\u660e Comb comb(N); \u7136\u540e comb.C(n, k) \u8fd4\u56de C(n,k) % MOD\nstruct Comb\n{\n    int n;\n    vector<ll> fact, invfact;\n    Comb(int _n) : n(_n)\n    {\n        fact.resize(n+1);\n        invfact.resize(n+1);\n        fact[0] = 1;\n        for (int i = 1; i <= n; ++i) fact[i] = fact[i-1] * i % MOD;\n        invfact[n] = qpow(fact[n], MOD-2, MOD);\n        for (int i = n-1; i >= 0; --i) invfact[i] = invfact[i+1] * (i+1) % MOD;\n    }\n    ll C(int a, int b)\n    {\n        if (b < 0 || b > a) return 0;\n        return fact[a] * invfact[b] % MOD * invfact[a-b] % MOD;\n    }\n};\n\n\/\/ \u77e9\u9635\u5feb\u901f\u5e42\uff08\u7528\u4e8e\u7ebf\u6027\u9012\u63a8\u4f18\u5316\uff09\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1aMatrix mat(n); \u8d4b\u503c mat.mat[i][j] = ...; \u7136\u540e mat.pow(p) \u8fd4\u56de mat^p\nstruct Matrix\n{\n    vector<vector<ll>> mat;\n    int n;\n    Matrix(int _n) : n(_n), mat(_n, vector<ll>(_n, 0)) {}\n    Matrix operator*(const Matrix& other) const\n    {\n        Matrix res(n);\n        for (int i = 0; i < n; ++i)\n            for (int k = 0; k < n; ++k)\n                if (mat[i][k] != 0)\n                    for (int j = 0; j < n; ++j)\n                        res.mat[i][j] = (res.mat[i][j] + mat[i][k] * other.mat[k][j]) % MOD;\n        return res;\n    }\n    Matrix pow(ll p) const\n    {\n        Matrix res(n), base = *this;\n        for (int i = 0; i < n; ++i) res.mat[i][i] = 1;\n        while (p)\n        {\n            if (p & 1) res = res * base;\n            base = base * base;\n            p >>= 1;\n        }\n        return res;\n    }\n};\n\n\/\/ \u6b27\u62c9\u51fd\u6570\uff08\u5355\u4e2a\u6570\uff09\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1aphi(n) \u8fd4\u56de \u03c6(n)\nll phi(ll n)\n{\n    ll res = n;\n    for (ll i = 2; i * i <= n; ++i)\n    {\n        if (n % i == 0)\n        {\n            while (n % i == 0) n \/= i;\n            res -= res \/ i;\n        }\n    }\n    if (n > 1) res -= res \/ n;\n    return res;\n}\n\n\/\/ \u7ebf\u6027\u7b5b\u6b27\u62c9\u51fd\u6570\uff08\u524d\u7f00\uff09\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1avector<ll> phi_arr = eulerPhi(n); phi_arr[i] \u4e3a \u03c6(i)\nvector<ll> eulerPhi(int n)\n{\n    vector<ll> phi(n+1);\n    vector<int> primes;\n    vector<bool> isComp(n+1, false);\n    phi[1] = 1;\n    for (int i = 2; i <= n; ++i)\n    {\n        if (!isComp[i]) { primes.push_back(i); phi[i] = i - 1; }\n        for (int p : primes)\n        {\n            if (i * p > n) break;\n            isComp[i*p] = true;\n            if (i % p == 0) { phi[i*p] = phi[i] * p; break; }\n            else phi[i*p] = phi[i] * (p - 1);\n        }\n    }\n    return phi;\n}\n\n\/\/ ====================== \u5e76\u67e5\u96c6 ======================\nstruct DSU\n{\n    vector<int> parent, rank_; \/\/ rank_ \u8bb0\u5f55\u6811\u7684\u9ad8\u5ea6\uff08\u79e9\uff09\n    \/\/ \u4f7f\u7528\u65b9\u6cd5\uff1aDSU dsu(n); dsu.unite(a,b); dsu.same(a,b); dsu.find(x);\n    DSU(int n)\n    {\n        parent.resize(n + 1);\n        rank_.resize(n + 1, 0);\n        for (int i = 1; i <= n; ++i) parent[i] = i;\n    }\n\n    int find(int x)\n    {\n        if (parent[x] != x) parent[x] = find(parent[x]); \/\/ \u8def\u5f84\u538b\u7f29\n        return parent[x];\n    }\n\n    void unite(int x, int y)\n    {\n        int rootX = find(x);\n        int rootY = find(y);\n        if (rootX == rootY) return;\n        \/\/ \u6309\u79e9\u5408\u5e76\n        if (rank_[rootX] < rank_[rootY]) parent[rootX] = rootY;\n        else if (rank_[rootX] > rank_[rootY]) parent[rootY] = rootX;\n        else { parent[rootY] = rootX; rank_[rootX]++; }\n    }\n\n    bool same(int x, int y) { return find(x) == find(y); }\n};\n\n\/\/ ====================== \u56fe\u8bba ======================\n\n\/**\n * Dijkstra \u5355\u6e90\u6700\u77ed\u8def\uff08\u5806\u4f18\u5316\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<vector<pair<int,ll>>> g(n+1); \/\/ g[u].push_back({v, w})\n *   vector<ll> dist = dijkstra(n, g, s);\n *   dist[i] \u4e3a\u4ece s \u5230 i \u7684\u6700\u77ed\u8ddd\u79bb\uff0c\u4e0d\u53ef\u8fbe\u4e3a LLONG_MAX\n *\/\nvector<ll> dijkstra(int n, const vector<vector<pair<int, ll>>> &g, int s)\n{\n    vector<ll> dist(n + 1, LLONG_MAX);\n    vector<bool> vis(n + 1, false);\n    dist[s] = 0;\n    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> pq;\n    pq.push({0, s});\n    while (!pq.empty())\n    {\n        auto [d, u] = pq.top(); pq.pop();\n        if (vis[u]) continue;\n        vis[u] = true;\n        for (auto [v, w] : g[u])\n        {\n            if (dist[v] > dist[u] + w)\n            {\n                dist[v] = dist[u] + w;\n                pq.push({dist[v], v});\n            }\n        }\n    }\n    return dist;\n}\n\n\/**\n * Bellman-Ford \u7b97\u6cd5\uff08\u53ef\u68c0\u6d4b\u8d1f\u73af\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<tuple<int,int,ll>> edges; \/\/ edges.push_back({u,v,w})\n *   vector<ll> dist = bellmanFord(n, edges, s);\n *   \u82e5\u8fd4\u56de\u7a7a vector \u5219\u8868\u793a\u5b58\u5728\u8d1f\u73af\n *\/\nvector<ll> bellmanFord(int n, const vector<tuple<int, int, ll>> &edges, int s)\n{\n    vector<ll> dist(n + 1, LLONG_MAX);\n    dist[s] = 0;\n    for (int i = 1; i < n; ++i)\n    {\n        bool updated = false;\n        for (auto [u, v, w] : edges)\n        {\n            if (dist[u] != LLONG_MAX && dist[v] > dist[u] + w)\n            {\n                dist[v] = dist[u] + w;\n                updated = true;\n            }\n        }\n        if (!updated) break;\n    }\n    \/\/ \u7b2c n \u8f6e\u68c0\u67e5\u8d1f\u73af\n    for (auto [u, v, w] : edges)\n        if (dist[u] != LLONG_MAX && dist[v] > dist[u] + w)\n            return {};\n    return dist;\n}\n\n\/**\n * Floyd-Warshall \u591a\u6e90\u6700\u77ed\u8def\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<vector<ll>> g(n+1, vector<ll>(n+1, LLONG_MAX));\n *   \u8bbe\u7f6e g[i][i] = 0, g[u][v] = w\n *   \u8c03\u7528 floyd(n, g); \u4e4b\u540e g[i][j] \u5373\u4e3a i->j \u6700\u77ed\u8def\n *\/\nvoid floyd(int n, vector<vector<ll>> &g)\n{\n    for (int k = 1; k <= n; ++k)\n        for (int i = 1; i <= n; ++i)\n            for (int j = 1; j <= n; ++j)\n                if (g[i][k] != LLONG_MAX && g[k][j] != LLONG_MAX)\n                    g[i][j] = min(g[i][j], g[i][k] + g[k][j]);\n}\n\n\/**\n * \u62d3\u6251\u6392\u5e8f\uff08Kahn \u7b97\u6cd5\uff0c\u57fa\u4e8e BFS\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<vector<int>> g(n+1); \/\/ \u6709\u5411\u56fe\u90bb\u63a5\u8868\n *   vector<int> topo = topoSort(n, g);\n *   \u82e5\u5b58\u5728\u73af\u5219\u8fd4\u56de\u7a7a vector\uff0c\u5426\u5219\u8fd4\u56de\u62d3\u6251\u5e8f\uff08\u4ece 1 \u5230 n \u987a\u5e8f\uff09\n *\/\nvector<int> topoSort(int n, const vector<vector<int>> &g)\n{\n    vector<int> indeg(n + 1, 0);\n    for (int u = 1; u <= n; ++u)\n        for (int v : g[u]) indeg[v]++;\n    queue<int> q;\n    for (int i = 1; i <= n; ++i)\n        if (indeg[i] == 0) q.push(i);\n    vector<int> topo;\n    while (!q.empty())\n    {\n        int u = q.front(); q.pop();\n        topo.push_back(u);\n        for (int v : g[u])\n            if (--indeg[v] == 0) q.push(v);\n    }\n    if ((int)topo.size() != n) return {}; \/\/ \u6709\u73af\n    return topo;\n}\n\n\/**\n * \u5308\u7259\u5229\u7b97\u6cd5\uff08\u4e8c\u5206\u56fe\u6700\u5927\u5339\u914d\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<vector<int>> g(n+1); \/\/ \u5de6\u90e8\u70b9 u \u53ef\u5339\u914d\u7684\u53f3\u90e8\u70b9\u5217\u8868\uff081-indexed\uff09\n *   int match_count = hungarian(n, m, g); \/\/ n \u4e3a\u5de6\u90e8\u70b9\u6570\uff0cm \u4e3a\u53f3\u90e8\u70b9\u6570\n *\/\nint hungarian(int n, int m, const vector<vector<int>> &g)\n{\n    vector<int> matchR(m + 1, 0);\n    int res = 0;\n    vector<bool> vis;\n\n    function<bool(int)> dfs = [&](int u)\n    {\n        for (int v : g[u])\n        {\n            if (vis[v]) continue;\n            vis[v] = true;\n            if (matchR[v] == 0 || dfs(matchR[v]))\n            {\n                matchR[v] = u;\n                return true;\n            }\n        }\n        return false;\n    };\n\n    for (int u = 1; u <= n; ++u)\n    {\n        vis.assign(m + 1, false);\n        if (dfs(u)) res++;\n    }\n    return res;\n}\n\n\/**\n * Tarjan \u6c42\u5f3a\u8fde\u901a\u5206\u91cf\uff08\u7f29\u70b9\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   TarjanSCC scc(n, g); \/\/ \u4f20\u5165\u90bb\u63a5\u8868 g\n *   \u4e4b\u540e scc.scc_id[u] \u4e3a u \u6240\u5c5e\u7684 SCC \u7f16\u53f7\uff081..scc_cnt\uff09\uff0cscc.scc_cnt \u4e3a\u603b\u6570\n *\/\nstruct TarjanSCC\n{\n    int n, timestamp, scc_cnt;\n    vector<vector<int>> g;\n    vector<int> dfn, low, stk, scc_id;\n    vector<bool> in_stk;\n\n    TarjanSCC(int _n, const vector<vector<int>> &_g) : n(_n), g(_g)\n    {\n        dfn.assign(n + 1, 0);\n        low.assign(n + 1, 0);\n        scc_id.assign(n + 1, 0);\n        in_stk.assign(n + 1, false);\n        timestamp = 0;\n        scc_cnt = 0;\n        for (int i = 1; i <= n; ++i)\n            if (!dfn[i]) dfs(i);\n    }\n\n    void dfs(int u)\n    {\n        dfn[u] = low[u] = ++timestamp;\n        stk.push_back(u);\n        in_stk[u] = true;\n        for (int v : g[u])\n        {\n            if (!dfn[v])\n            {\n                dfs(v);\n                low[u] = min(low[u], low[v]);\n            }\n            else if (in_stk[v])\n            {\n                low[u] = min(low[u], dfn[v]);\n            }\n        }\n        if (dfn[u] == low[u])\n        {\n            scc_cnt++;\n            int v;\n            do\n            {\n                v = stk.back(); stk.pop_back();\n                in_stk[v] = false;\n                scc_id[v] = scc_cnt;\n            } while (v != u);\n        }\n    }\n};\n\n\/**\n * LCA \u500d\u589e\u6cd5\uff08\u9884\u5904\u7406 O(n log n)\uff0c\u67e5\u8be2 O(log n)\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   LCA lca(n, g); \/\/ g \u4e3a\u6811\u7684\u65e0\u5411\u90bb\u63a5\u8868\uff081-indexed\uff09\n *   lca.init(root);\n *   int anc = lca.lca(a, b);\n *\/\nstruct LCA\n{\n    int n, LOG;\n    vector<vector<int>> g, up;\n    vector<int> depth;\n    LCA(int _n, const vector<vector<int>> &_g) : n(_n), g(_g)\n    {\n        LOG = __lg(n) + 1;\n        up.assign(n + 1, vector<int>(LOG));\n        depth.assign(n + 1, 0);\n    }\n    void dfs(int u, int p)\n    {\n        up[u][0] = p;\n        for (int i = 1; i < LOG; ++i)\n            up[u][i] = up[ up[u][i-1] ][i-1];\n        for (int v : g[u])\n        {\n            if (v == p) continue;\n            depth[v] = depth[u] + 1;\n            dfs(v, u);\n        }\n    }\n    void init(int root)\n    {\n        depth[root] = 0;\n        dfs(root, root);\n    }\n    int lca(int a, int b)\n    {\n        if (depth[a] < depth[b]) swap(a, b);\n        int diff = depth[a] - depth[b];\n        for (int i = 0; i < LOG; ++i)\n            if (diff >> i & 1) a = up[a][i];\n        if (a == b) return a;\n        for (int i = LOG - 1; i >= 0; --i)\n            if (up[a][i] != up[b][i])\n                a = up[a][i], b = up[b][i];\n        return up[a][0];\n    }\n};\n\n\/**\n * Prim \u6700\u5c0f\u751f\u6210\u6811\uff08\u5806\u4f18\u5316\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<vector<pair<int,ll>>> g(n+1); \/\/ \u65e0\u5411\u56fe\u90bb\u63a5\u8868\uff0c\u5b58\u5165 {v, w}\n *   ll mst_w = prim(n, g); \u82e5\u4e0d\u8fde\u901a\u8fd4\u56de -1\n *\/\nll prim(int n, const vector<vector<pair<int, ll>>> &g)\n{\n    vector<bool> vis(n + 1, false);\n    priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> pq;\n    pq.push({0, 1}); \/\/ \u4ece 1 \u5f00\u59cb\n    ll ans = 0;\n    int cnt = 0;\n    while (!pq.empty() && cnt < n)\n    {\n        auto [w, u] = pq.top(); pq.pop();\n        if (vis[u]) continue;\n        vis[u] = true;\n        ans += w;\n        cnt++;\n        for (auto [v, c] : g[u])\n            if (!vis[v]) pq.push({c, v});\n    }\n    return (cnt == n) ? ans : -1;\n}\n\n\/\/ Kruskal \u7b97\u6cd5\nstruct Edge\n{\n    int u, v, w;\n    bool operator<(const Edge &other) const { return w < other.w; }\n};\nint kruskal(int n, const vector<Edge> &edges)\n{\n    vector<Edge> sortedEdges = edges;\n    sort(sortedEdges.begin(), sortedEdges.end());\n    DSU dsu(n);\n    int mst_weight = 0, cnt = 0;\n    for (const auto &e : sortedEdges)\n    {\n        if (!dsu.same(e.u, e.v))\n        {\n            dsu.unite(e.u, e.v);\n            mst_weight += e.w;\n            cnt++;\n            if (cnt == n - 1) break;\n        }\n    }\n    return (cnt == n - 1) ? mst_weight : -1;\n}\n\n\/\/ ====================== \u6570\u636e\u7ed3\u6784 ======================\n\n\/**\n * \u6811\u72b6\u6570\u7ec4\uff08Fenwick Tree\uff09 1-indexed\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   BIT bit(n);\n *   bit.add(idx, delta);\n *   ll sum = bit.sum(idx);    \/\/ [1, idx]\n *   ll range = bit.rangeSum(l, r);\n *\/\nstruct BIT\n{\n    int n;\n    vector<ll> tree;\n    BIT(int _n) : n(_n), tree(_n + 2, 0) {}\n    void add(int idx, ll delta)\n    {\n        while (idx <= n)\n        {\n            tree[idx] += delta;\n            idx += idx & -idx;\n        }\n    }\n    ll sum(int idx) \/\/ [1, idx]\n    {\n        ll res = 0;\n        while (idx > 0)\n        {\n            res += tree[idx];\n            idx -= idx & -idx;\n        }\n        return res;\n    }\n    ll rangeSum(int l, int r) { return sum(r) - sum(l - 1); }\n};\n\n\/**\n * \u7ebf\u6bb5\u6811\uff08\u533a\u95f4\u52a0\u3001\u533a\u95f4\u6c42\u548c\uff0c\u5e26\u61d2\u6807\u8bb0\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   SegTree seg(n);\n *   seg.rangeAdd(l, r, val);\n *   ll sum = seg.rangeSum(l, r);\n *\/\nstruct SegTree\n{\n    int n;\n    vector<ll> sum, lazy;\n    SegTree(int _n) : n(_n), sum(4 * _n + 5), lazy(4 * _n + 5) {}\n\n    void push(int p, int l, int r)\n    {\n        if (lazy[p] != 0)\n        {\n            int mid = (l + r) >> 1;\n            sum[p<<1] += lazy[p] * (mid - l + 1);\n            sum[p<<1|1] += lazy[p] * (r - mid);\n            lazy[p<<1] += lazy[p];\n            lazy[p<<1|1] += lazy[p];\n            lazy[p] = 0;\n        }\n    }\n\n    void update(int p, int l, int r, int ql, int qr, ll val)\n    {\n        if (ql <= l && r <= qr)\n        {\n            sum[p] += val * (r - l + 1);\n            lazy[p] += val;\n            return;\n        }\n        push(p, l, r);\n        int mid = (l + r) >> 1;\n        if (ql <= mid) update(p<<1, l, mid, ql, qr, val);\n        if (qr > mid) update(p<<1|1, mid+1, r, ql, qr, val);\n        sum[p] = sum[p<<1] + sum[p<<1|1];\n    }\n\n    ll query(int p, int l, int r, int ql, int qr)\n    {\n        if (ql <= l && r <= qr) return sum[p];\n        push(p, l, r);\n        int mid = (l + r) >> 1;\n        ll res = 0;\n        if (ql <= mid) res += query(p<<1, l, mid, ql, qr);\n        if (qr > mid) res += query(p<<1|1, mid+1, r, ql, qr);\n        return res;\n    }\n\n    void rangeAdd(int l, int r, ll val) { update(1, 1, n, l, r, val); }\n    ll rangeSum(int l, int r) { return query(1, 1, n, l, r); }\n};\n\n\/**\n * ST \u8868\uff08\u9759\u6001\u533a\u95f4\u6700\u5927\u503c\uff0c\u4e0d\u652f\u6301\u4fee\u6539\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<ll> a(n+1); a[1..n]\n *   SparseTable st(a);\n *   ll mx = st.query(l, r); \/\/ \u95ed\u533a\u95f4 [l, r] \u6700\u5927\u503c\n *\/\nstruct SparseTable\n{\n    vector<vector<ll>> st;\n    vector<int> log;\n    SparseTable(const vector<ll>& a)\n    {\n        int n = a.size() - 1; \/\/ a[1..n]\n        log.resize(n + 2);\n        log[1] = 0;\n        for (int i = 2; i <= n + 1; ++i) log[i] = log[i\/2] + 1;\n        int K = log[n] + 1;\n        st.assign(n + 1, vector<ll>(K));\n        for (int i = 1; i <= n; ++i) st[i][0] = a[i];\n        for (int j = 1; j < K; ++j)\n            for (int i = 1; i + (1<<j) - 1 <= n; ++i)\n                st[i][j] = max(st[i][j-1], st[i + (1<<(j-1))][j-1]);\n    }\n    ll query(int l, int r)\n    {\n        int j = log[r - l + 1];\n        return max(st[l][j], st[r - (1<<j) + 1][j]);\n    }\n};\n\n\/\/ \u5355\u8c03\u6808\uff1a\u6c42\u6bcf\u4e2a\u4f4d\u7f6e\u5de6\u8fb9\u7b2c\u4e00\u4e2a\u66f4\u5c0f\u7684\u5143\u7d20\u7684\u4e0b\u6807\uff08\u793a\u4f8b\uff09\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1aauto left = leftSmaller(a);  left[i] \u4e3a\u4e0b\u6807\uff0c\u82e5\u65e0\u5219\u4e3a -1\nvector<int> leftSmaller(const vector<int>& a)\n{\n    int n = a.size();\n    vector<int> res(n, -1);\n    stack<int> st;\n    for (int i = 0; i < n; ++i)\n    {\n        while (!st.empty() && a[st.top()] >= a[i]) st.pop();\n        res[i] = st.empty() ? -1 : st.top();\n        st.push(i);\n    }\n    return res;\n}\n\n\/\/ \u5355\u8c03\u961f\u5217\uff1a\u6ed1\u52a8\u7a97\u53e3\u6700\u5927\u503c\n\/\/ \u4f7f\u7528\u65b9\u6cd5\uff1aauto mx = slidingWindowMax(a, k); \u8fd4\u56de\u6bcf\u4e2a\u7a97\u53e3\u6700\u5927\u503c\u7684\u5217\u8868\nvector<int> slidingWindowMax(const vector<int>& a, int k)\n{\n    deque<int> dq;\n    vector<int> res;\n    for (int i = 0; i < (int)a.size(); ++i)\n    {\n        while (!dq.empty() && a[dq.back()] <= a[i]) dq.pop_back();\n        dq.push_back(i);\n        if (dq.front() <= i - k) dq.pop_front();\n        if (i >= k - 1) res.push_back(a[dq.front()]);\n    }\n    return res;\n}\n\n\/\/ ====================== \u5b57\u7b26\u4e32 ======================\n\n\/**\n * KMP \u7b97\u6cd5\uff1a\u8fd4\u56de\u6a21\u5f0f\u4e32 pat \u5728\u6587\u672c\u4e32 txt \u4e2d\u7684\u6240\u6709\u51fa\u73b0\u4f4d\u7f6e\uff080-indexed\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1aauto occ = kmpSearch(txt, pat); \u8fd4\u56de\u8d77\u59cb\u4e0b\u6807\u5217\u8868\n *\/\nvector<int> kmpSearch(const string& txt, const string& pat)\n{\n    string s = pat + \"#\" + txt;\n    int n = s.size(), m = pat.size();\n    vector<int> nxt(n, 0);\n    for (int i = 1; i < n; ++i)\n    {\n        int j = nxt[i-1];\n        while (j > 0 && s[i] != s[j]) j = nxt[j-1];\n        if (s[i] == s[j]) j++;\n        nxt[i] = j;\n    }\n    vector<int> res;\n    for (int i = m+1; i < n; ++i)\n        if (nxt[i] == m) res.push_back(i - 2*m);\n    return res;\n}\n\n\/**\n * Manacher \u7b97\u6cd5\uff1a\u6c42\u6700\u957f\u56de\u6587\u5b50\u4e32\u957f\u5ea6\n * \u4f7f\u7528\u65b9\u6cd5\uff1aint len = manacher(s); \u8fd4\u56de\u6700\u957f\u56de\u6587\u5b50\u4e32\u7684\u957f\u5ea6\n *\/\nint manacher(const string& s)\n{\n    string t = \"#\";\n    for (char c : s) t += c, t += '#';\n    int n = t.size();\n    vector<int> p(n, 0);\n    int center = 0, right = 0;\n    for (int i = 0; i < n; ++i)\n    {\n        int mirror = 2 * center - i;\n        if (i < right) p[i] = min(right - i, p[mirror]);\n        while (i - p[i] - 1 >= 0 && i + p[i] + 1 < n && t[i-p[i]-1] == t[i+p[i]+1]) p[i]++;\n        if (i + p[i] > right)\n        {\n            center = i;\n            right = i + p[i];\n        }\n    }\n    return *max_element(p.begin(), p.end());\n}\n\n\/**\n * \u53cc\u54c8\u5e0c\u5b57\u7b26\u4e32\u54c8\u5e0c\uff08\u9632\u78b0\u649e\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   DoubleHash dh(s);\n *   auto [h1, h2] = dh.getHash(l, r); \/\/ 0-indexed \u95ed\u533a\u95f4 [l, r]\n *   \u53ef\u76f4\u63a5\u6bd4\u8f83\u4e24\u4e2a\u5b50\u4e32\u54c8\u5e0c\u662f\u5426\u76f8\u7b49\n *\/\nstruct DoubleHash\n{\n    static const ll base = 91138233;\n    static const ll mod1 = 1e9+7, mod2 = 1e9+9;\n    vector<ll> h1, h2, pow1, pow2;\n    DoubleHash(const string& s)\n    {\n        int n = s.size();\n        h1.resize(n+1); h2.resize(n+1);\n        pow1.resize(n+1); pow2.resize(n+1);\n        pow1[0] = pow2[0] = 1;\n        for (int i = 1; i <= n; ++i)\n        {\n            pow1[i] = pow1[i-1] * base % mod1;\n            pow2[i] = pow2[i-1] * base % mod2;\n        }\n        for (int i = 1; i <= n; ++i)\n        {\n            h1[i] = (h1[i-1] * base + s[i-1]) % mod1;\n            h2[i] = (h2[i-1] * base + s[i-1]) % mod2;\n        }\n    }\n    pair<ll,ll> getHash(int l, int r) \/\/ 0-indexed, [l, r]\n    {\n        ll v1 = (h1[r+1] - h1[l] * pow1[r-l+1] % mod1 + mod1) % mod1;\n        ll v2 = (h2[r+1] - h2[l] * pow2[r-l+1] % mod2 + mod2) % mod2;\n        return {v1, v2};\n    }\n};\n\n\/\/ ====================== \u8ba1\u7b97\u51e0\u4f55 ======================\n\nstruct Point\n{\n    double x, y;\n    Point(double x=0, double y=0) : x(x), y(y) {}\n    Point operator+(const Point& p) const { return {x+p.x, y+p.y}; }\n    Point operator-(const Point& p) const { return {x-p.x, y-p.y}; }\n    double dot(const Point& p) const { return x*p.x + y*p.y; }\n    double cross(const Point& p) const { return x*p.y - y*p.x; }\n    double len2() const { return x*x + y*y; }\n    double len() const { return sqrt(len2()); }\n    bool operator<(const Point& p) const { return x != p.x ? x < p.x : y < p.y; }\n};\n\n\/**\n * Andrew \u51f8\u5305\u7b97\u6cd5\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<Point> pts;\n *   vector<Point> hull = convexHull(pts);\n *   \u8fd4\u56de\u9006\u65f6\u9488\u51f8\u5305\u70b9\u96c6\uff08\u4e0d\u542b\u91cd\u590d\u7aef\u70b9\uff0c\u6700\u540e\u4e00\u70b9\u4e0d\u4e0e\u8d77\u70b9\u91cd\u590d\uff09\n *\/\nvector<Point> convexHull(vector<Point> pts)\n{\n    int n = pts.size();\n    if (n <= 1) return pts;\n    sort(pts.begin(), pts.end());\n    vector<Point> hull;\n    \/\/ \u4e0b\u51f8\u5305\n    for (int i = 0; i < n; ++i)\n    {\n        while (hull.size() >= 2 && (hull.back() - hull[hull.size()-2]).cross(pts[i] - hull.back()) <= 0)\n            hull.pop_back();\n        hull.push_back(pts[i]);\n    }\n    int lower = hull.size();\n    \/\/ \u4e0a\u51f8\u5305\n    for (int i = n-2; i >= 0; --i)\n    {\n        while (hull.size() > lower && (hull.back() - hull[hull.size()-2]).cross(pts[i] - hull.back()) <= 0)\n            hull.pop_back();\n        hull.push_back(pts[i]);\n    }\n    if (hull.size() > 1) hull.pop_back(); \/\/ \u79fb\u9664\u8d77\u70b9\u91cd\u590d\n    return hull;\n}\n\n\/\/ ====================== DP \u4f18\u5316\uff08\u793a\u4f8b\uff09 ======================\n\n\/**\n * \u5355\u8c03\u961f\u5217\u4f18\u5316 DP \u6846\u67b6\n * \u95ee\u9898\uff1adp[i] = min_{j\u2208[i-m, i-1]} (dp[j] + (a[i]-a[j])^2)\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\u6839\u636e\u5177\u4f53\u9898\u76ee\u4fee\u6539\u8f6c\u79fb\u65b9\u7a0b\uff0c\u6b64\u5904\u4ec5\u5c55\u793a\u6846\u67b6\n *\/\nll monotoneQueueDP(const vector<ll>& a, int m)\n{\n    int n = a.size();\n    vector<ll> dp(n, 0);\n    deque<int> dq;\n    for (int i = 0; i < n; ++i)\n    {\n        while (!dq.empty() && dq.front() < i - m) dq.pop_front();\n        if (!dq.empty())\n            dp[i] = dp[dq.front()] + (a[i] - a[dq.front()]) * (a[i] - a[dq.front()]);\n        else\n            dp[i] = (i == 0 ? 0 : LLONG_MAX\/2);\n        while (!dq.empty() && dp[dq.back()] >= dp[i]) dq.pop_back();\n        dq.push_back(i);\n    }\n    return dp[n-1];\n}\n\n\/\/ ====================== \u641c\u7d22\u4e0e\u72b6\u6001\u538b\u7f29 ======================\n\n\/**\n * \u53cc\u5411 BFS\uff08\u793a\u4f8b\uff1a\u72b6\u6001\u4e3a\u6574\u6570\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   auto getNext = [&](int state) -> vector<int> { ... };\n *   int steps = bidirectionalBFS(start, target, getNext);\n *   \u8fd4\u56de\u6700\u5c11\u6b65\u6570\uff0c\u82e5\u65e0\u6cd5\u5230\u8fbe\u5219\u8fd4\u56de -1\n *\/\nint bidirectionalBFS(int start, int target, function<vector<int>(int)> getNext)\n{\n    if (start == target) return 0;\n    queue<int> q1, q2;\n    unordered_map<int, int> dist1, dist2;\n    q1.push(start); dist1[start] = 0;\n    q2.push(target); dist2[target] = 0;\n\n    auto extend = [&](queue<int>& q, unordered_map<int,int>& dist, unordered_map<int,int>& distOther) -> int\n    {\n        int u = q.front(); q.pop();\n        int d = dist[u];\n        for (int v : getNext(u))\n        {\n            if (dist.count(v)) continue;\n            if (distOther.count(v)) return d + 1 + distOther[v];\n            dist[v] = d + 1;\n            q.push(v);\n        }\n        return -1;\n    };\n\n    while (!q1.empty() && !q2.empty())\n    {\n        int res;\n        if (q1.size() <= q2.size()) res = extend(q1, dist1, dist2);\n        else res = extend(q2, dist2, dist1);\n        if (res != -1) return res;\n    }\n    return -1;\n}\n\n\/**\n * \u72b6\u6001\u538b\u7f29 DP \u793a\u4f8b\uff1aTSP\uff08\u65c5\u884c\u5546\u95ee\u9898\uff09\n * \u4f7f\u7528\u65b9\u6cd5\uff1a\n *   vector<vector<ll>> dist(n, vector<ll>(n)); \/\/ dist[u][v] \u8ddd\u79bb\n *   ll ans = tsp(dist); \u8fd4\u56de\u4ece 0 \u51fa\u53d1\u3001\u904d\u5386\u6240\u6709\u70b9\u5e76\u8fd4\u56de 0 \u7684\u6700\u77ed\u8def\u5f84\u957f\u5ea6\n *\/\nll tsp(const vector<vector<ll>>& dist)\n{\n    int n = dist.size();\n    vector<vector<ll>> dp(1 << n, vector<ll>(n, LLONG_MAX\/2));\n    dp[1][0] = 0; \/\/ \u8d77\u70b9 0\n    for (int mask = 1; mask < (1 << n); ++mask)\n    {\n        for (int u = 0; u < n; ++u)\n        {\n            if (!(mask >> u & 1)) continue;\n            for (int v = 0; v < n; ++v)\n            {\n                if (mask >> v & 1) continue;\n                int nxt = mask | (1 << v);\n                dp[nxt][v] = min(dp[nxt][v], dp[mask][u] + dist[u][v]);\n            }\n        }\n    }\n    ll ans = LLONG_MAX\/2;\n    int all = (1 << n) - 1;\n    for (int u = 0; u < n; ++u)\n        ans = min(ans, dp[all][u] + dist[u][0]);\n    return ans;\n}\n\n\/\/ ====================== \u8fdb\u5236\u8f6c\u6362\u4e0e\u4e8c\u5206\u67e5\u627e ======================\n\n\/\/ \u5c06\u5b57\u7b26\u8f6c\u6362\u6210\u6570\u503c (0~35)\nint charToVal(char c)\n{\n    if (c >= '0' && c <= '9') return c - '0';\n    return toupper(c) - 'A' + 10; \/\/ \u652f\u6301\u5927\u5c0f\u5199\n}\n\n\/\/ \u5c06\u6570\u503c\u8f6c\u6362\u6210\u5b57\u7b26 (0~35)\nchar valToChar(int v)\n{\n    if (v < 10) return '0' + v;\n    return 'A' + v - 10;\n}\n\n\/\/ \u8fdb\u5236\u8f6c\u6362\u6838\u5fc3\u51fd\u6570\nstring convertBase(const string &s, int fromBase, int toBase)\n{\n    if (s.empty()) return \"0\";\n    vector<int> num;\n    for (char c : s) num.push_back(charToVal(c));\n\n    string result;\n    while (!num.empty())\n    {\n        int remainder = 0;\n        vector<int> newNum;\n        for (size_t i = 0; i < num.size(); ++i)\n        {\n            int cur = remainder * fromBase + num[i];\n            int q = cur \/ toBase;\n            remainder = cur % toBase;\n            if (!newNum.empty() || q != 0) newNum.push_back(q);\n        }\n        result.push_back(valToChar(remainder));\n        num = newNum;\n    }\n    reverse(result.begin(), result.end());\n    return result.empty() ? \"0\" : result;\n}\n\nbool check(ll mid) \n{ \n    \/\/ \u6839\u636e\u5b9e\u9645\u95ee\u9898\u4fee\u6539\u5224\u65ad\u6761\u4ef6\n    return mid; \n}\n\nll binarySearch(ll l, ll r, bool findFirst = true)\n{\n    \/\/ findFirst = true: \u5de6\u8fb9\u754c\u67e5\u627e\uff08\u7b2c\u4e00\u4e2a\u6ee1\u8db3\u6761\u4ef6\u7684\uff09\n    \/\/ findFirst = false: \u53f3\u8fb9\u754c\u67e5\u627e\uff08\u6700\u540e\u4e00\u4e2a\u6ee1\u8db3\u6761\u4ef6\u7684\uff09\n    if (findFirst)\n    {\n        while (l < r)\n        {\n            ll mid = l + ((r - l) >> 1);\n            if (check(mid)) r = mid;\n            else l = mid + 1;\n        }\n        return check(l) ? l : r + 1;\n    }\n    else\n    {\n        while (l < r)\n        {\n            ll mid = l + ((r - l + 1) >> 1);\n            if (check(mid)) l = mid;\n            else r = mid - 1;\n        }\n        return check(l) ? l : -1;\n    }\n}\n\n\/\/ ====================== \u4e3b\u51fd\u6570\u4e0e solve \u6846\u67b6 ======================\nvoid solve()\n{\n    \/\/ \u5728\u6b64\u7f16\u5199\u9898\u76ee\u6c42\u89e3\u903b\u8f91\n}\n\nint main()\n{\n    ios::sync_with_stdio(false);\n    cin.tie(nullptr);\n    cout.tie(nullptr);\n\n    int T = 1;\n    \/\/ cin >> T; \/\/ \u591a\u7ec4\u6d4b\u8bd5\u6570\u636e\u65f6\u53d6\u6d88\u6ce8\u91ca\n    while (T--)\n    {\n        solve();\n    }\n    return 0;\n}<\/code><\/pre>\n\n\n\n
\u5173\u4e8e\u6a21\u677f\u7684\u5b66\u4e60\u4e0e\u4f7f\u7528\u5efa\u8bae\uff1a<\/p>\n\n\n\n
    \n
  1. \u7406\u89e3\u4f18\u5148\u4e8e\u8bb0\u5fc6\uff1a\u5728\u4f7f\u7528\u4efb\u4f55\u6a21\u677f\u524d\uff0c\u52a1\u5fc5\u7406\u89e3\u5176\u5b9e\u73b0\u539f\u7406\u548c\u9002\u7528\u573a\u666f\u3002\u4f8b\u5982\uff0c\u7406\u89e3\u5feb\u901f\u5e42\u7684\u4e8c\u8fdb\u5236\u5206\u89e3\u601d\u60f3\uff0c\u6bd4\u5355\u7eaf\u80cc\u8bf5\u4ee3\u7801\u66f4\u91cd\u8981\u3002<\/li>\n\n\n\n
  2. \u523b\u610f\u7ec3\u4e60\u5f62\u6210\u808c\u8089\u8bb0\u5fc6\uff1a\u5bf9\u4e8e\u5e38\u7528\u6a21\u677f\uff08\u5982\u5feb\u901f\u5e42\u3001\u5e76\u67e5\u96c6\u3001\u4e8c\u5206\u67e5\u627e\uff09\uff0c\u5e94\u901a\u8fc7\u53cd\u590d\u6572\u6253\u76f4\u81f3\u719f\u7ec3\uff0c\u4f7f\u5176\u5728\u6bd4\u8d5b\u65f6\u80fd\u5feb\u901f\u3001\u51c6\u786e\u5730\u5199\u51fa\u3002<\/li>\n\n\n\n
  3. \u6839\u636e\u6bd4\u8d5b\u9700\u6c42\u7075\u6d3b\u88c1\u526a\uff1a\u5728ICPC\u3001CCPC\u7b49\u56e2\u961f\u8d5b\u4e2d\uff0c\u53ef\u4ee5\u6307\u6d3e\u4e00\u540d\u961f\u5458\u63d0\u524d\u51c6\u5907\u597d\u5305\u542b\u66f4\u5168\u7b97\u6cd5\u7684\u201c\u677f\u5b50\u201d\u3002\u4f46\u5177\u4f53\u5230\u6bcf\u9053\u9898\uff0c\u5e94\u53ea\u4fdd\u7559\u5fc5\u8981\u7684\u90e8\u5206\uff0c\u4fdd\u6301\u4ee3\u7801\u6e05\u6670\u3002<\/li>\n\n\n\n
  4. \u4fdd\u6301\u66f4\u65b0\u4e0e\u8fed\u4ee3\uff1a\u968f\u7740\u5b66\u4e60\u7684\u6df1\u5165\uff0c\u4f60\u4f1a\u9047\u5230\u66f4\u4f18\u7684\u5b9e\u73b0\u6216\u66f4\u9002\u5408\u81ea\u5df1\u4e60\u60ef\u7684\u5199\u6cd5\u3002\u5b9a\u671f\u56de\u987e\u5e76\u4f18\u5316\u81ea\u5df1\u7684\u6a21\u677f\u5e93\uff0c\u662f\u6301\u7eed\u8fdb\u6b65\u7684\u91cd\u8981\u4e00\u73af\u3002<\/li>\n<\/ol>\n\n\n\n
    \u6a21\u677f\u662f\u5de5\u5177\uff0c\u80fd\u5e2e\u4f60\u63d0\u9ad8\u6548\u7387\uff0c\u4f46\u4e0d\u80fd\u66ff\u4ee3\u601d\u8003\u3002\u624e\u5b9e\u7684\u57fa\u7840\u3001\u6e05\u6670\u7684\u903b\u8f91\u548c\u7a33\u5b9a\u7684\u5fc3\u6001\uff0c\u624d\u662f\u89e3\u51b3\u96be\u9898\u7684\u6839\u672c\u3002<\/p>\n\n\n\n
    \u4e0b\u9762\u7b97\u6cd5\u5fc3\u4f20\u7cfb\u5217\u4f1a\u5bf9\u5e38\u7528\u7684\u7b97\u6cd5\u6a21\u677f\u4e00\u4e00\u8bb2\u89e3\uff0c\u6df1\u5ea6\u5256\u6790\uff0c\u5e2e\u52a9\u5927\u5bb6\u53ef\u4ee5\u7075\u6d3b\u4f7f\u7528\uff0c\u66f4\u6df1\u523b\u7684\u7406\u89e3\u7b97\u6cd5\u7ade\u8d5b\u6a21\u677f\u7684\u8fd0\u7528\u3002<\/p>\n\n\n\n
    \u6211\u4f1a\u6301\u7eed\u4f18\u5316\u8fd9\u4efd\u6a21\u677f\uff0c\u5e76\u5728\u6211\u7684\u535a\u5ba2\u4e2d\u66f4\u65b0\u3002\u795d\u613f\u5404\u4f4d\u5728\u7b97\u6cd5\u4e4b\u8def\u4e0a\u4e0d\u65ad\u7cbe\u8fdb\uff0c\u5728\u6bd4\u8d5b\u4e2d\u53d6\u5f97\u7406\u60f3\u7684\u6210\u7ee9\uff01\uff01\uff01<\/p>\n","protected":false},"excerpt":{"rendered":"
    Simplicity is the ultimate form&nbs […]<\/p>\n","protected":false},"author":1,"featured_media":156,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1,15,12],"tags":[],"class_list":["post-154","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-article","category-algorithm-template","category-programming-algorithm-road"],"_links":{"self":[{"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/posts\/154","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/comments?post=154"}],"version-history":[{"count":17,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/posts\/154\/revisions"}],"predecessor-version":[{"id":451,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/posts\/154\/revisions\/451"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/media\/156"}],"wp:attachment":[{"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/media?parent=154"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/categories?post=154"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/jiangqvweihuan.cn\/index.php\/wp-json\/wp\/v2\/tags?post=154"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}