NoobDream_

【数据结构】树上问题——树上启发式合并

在阅读本文前，你应该对常见的树上问题有一定了解，并且有一定的练习量
前置知识：DFS序、树链剖分、树形DP等

文章目录

树上启发式合并简介
- 双log的启发式合并
- 单log的树上启发式合并
练习
- 树上数颜色
- CF600E - Lomsat gelral
- CF1009F - Dominant Indices
- CF570D - Tree Requests
- CF208E - Blood Cousins
- CF246E - Blood Cousins Return
- CF375D - Tree and Queries
- 2020 CCPC Wannafly Winter Camp Day2 阔力梯的树
- CSP202212-4 聚集方差
- 2022 CCPC女生赛 L. 彩色的树
- CF1709E - XOR Tree
- *CF741D - Arpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths
- *2020 CCPC Changchun F. Strange Memory
总结

树上启发式合并简介

树上启发式合并，又称dsu on tree、small to large merging，是一种能够在 $O (Nl o g N)$ 时间复杂度內回答子树问题的算法，优于树上莫队等。有一句话说得好——“提到子树，就想到树上启发式合并”，这更说明了这一算法的重要性。

双log的启发式合并

我们知道数据结构信息可以合并。给出若干个集合，每次要求将两个集合合并为一个新集合。一种朴素做法是，对于每次 $S_A \rightarrow S_B$ ，直接将源集合并入目标集合中。在合并次数较多、集合大小不定时，效率的低下是容易预见的。
启发式合并每次将小集合并入大集合，则对于每个元素而言，它每次被移动时，所在的集合大小至少扩大一倍，显然只能扩大 $O (l o g N)$ 次，因此总复杂度 $O (Nl o g N)$ 。

考虑单纯地把启发式合并迁移到树上，对于 $N$ 个结点，建立 $N$ 个集合，在DFS过程中，每当从子结点返回时，就将子结点集合与父结点集合合并，合并过程使用启发式合并优化。这一做法看似是 $O (Nl o g N)$ 的，实则无法达到，且通常至少是 $O(Nlog^2N)$ 级别的。原因就在于，在前文中，我们只是期望集合的操作都为 $O (1)$ 复杂度，这需要使用数组作为容器。而实际应用通常较为复杂，如果使用数组，空间复杂度常常会达到惊人的 $O(N^2)$ 甚至更高，这是不可接受的。考虑更换一些动态分配内存的容器，如std::set、std::map等，这可以降下空间复杂度，但同时，由于其单次操作的时间复杂度为 $O (l o g N)$ ，总体时间复杂度将升至 $O(Nlog^2N)$ ，在 $N=10^5$ 左右的规模还可以接受。

单log的树上启发式合并

真正的树上启发式合并又称为静态链分治，主要基于启发式合并的思想，考虑这样一个事实，重儿子所在子树总是最大的，可以作为大集合，轻儿子所在子树作为小集合，于是让子树根每次先继承重儿子的信息，再将轻儿子信息合并上来。这一过程可以使用一些技巧，让我们能够用数组达成目标，时间复杂度 $O (Nl o g N)$ 。

算法过程如下：

读入数据，建出树，将所有询问离线
第一遍DFS，预处理出DFS序、子树大小、重儿子等必要信息
第二遍DFS，对当前点
- 优先遍历轻儿子，对其进行内部统计、回答询问，返回后删除其对子树根结点的贡献
- 遍历重儿子，对其进行内部统计、回答询问，返回后保留其对子树根结点的贡献
- 将所有轻儿子的贡献加入子树根结点中
处理完毕，输出所有询问的答案

复杂度证明如下：

由树链剖分性质可知，任意一点到根结点路径上的轻边数不超过 $O (l o g N)$ ，每有一条轻边，该点就会被访问两次，一次删除贡献，一次加入贡献。直接与该点相连的轻边和重边还会使得该点被访问一次。此外，在第一遍预处理DFS中，每个点都被访问一次。故每个点的访问次数不会超过 $O (l o g N)$ ，总体时间复杂度 $O (Nl o g N)$ 。

由于可以使用全局数组实现，空间复杂度为 $O (N)$ 。

练习

本文习题中，将尽可能提供两种写法，可以自行比较运行时间和编码难度等优劣。通过对题目的多角度思考，将能够更全面地理解和运用树上启发式合并。~~并在绝大多数情况下学会偷懒！~~

树上数颜色

题目链接

题意：给定一棵树，树上每个结点有颜色 $C_i$ ，每次询问以某个结点为根的子树中共有多少种颜色。

思路：树上启发式合并的模板题，可使用set记录颜色再大力合并，也可用数组。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int c[MAXN], ans[MAXN];
vector<int> G[MAXN];
set<int> s[MAXN];

void dfs(int v, int fa)
{
    s[v].insert(c[v]);	// 加入根结点贡献
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs(u, v);
        if (s[v].size() < s[u].size())	// 保证根结点是大集合，使得每次总是小集合并入大集合
            swap(s[v], s[u]);
        s[v].merge(s[u]);	// 合并集合
        s[u].clear();	// 清空旧集合，否则最终会爆内存
    }
    ans[v] = s[v].size();
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n;
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    dfs(1, 0);
    cin >> m;
    while (m--)
    {
        int v;
        cin >> v;
        cout << ans[v] << "\n";
    }

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int sz[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int c[MAXN], s[MAXN], ans[MAXN], cnt;
vector<int> G[MAXN];

void dfs1(int v, int fa)	// 第一遍dfs，预处理必要信息
{
    L[v] = ++dfn;	// 当前结点dfs序
    id[dfn] = v;	// dfs序对应的结点编号
    sz[v] = 1;		// 子树大小
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])	// 子树更大的为重儿子
            son[v] = u;
    }
    R[v] = dfn;	// 当前子树中最大的dfs序（这说明子树內的dfs序是一段连续区间）
}

void dfs2(int v, int fa, bool keep) // 第二遍dfs，启发式合并，keep指示是否保留结点对集合的影响
{
    for (auto u : G[v])	// 先遍历轻儿子，不保留其对集合的影响
        if (u != son[v] && u != fa)
            dfs2(u, v, 0);
    if (son[v]) 	// 然后遍历重儿子，保留其对集合的影响
        dfs2(son[v], v, 1);

    if (!s[c[v]])	// 加入根结点对集合的贡献
        ++cnt, s[c[v]] = 1;
    for (auto u : G[v])	// 最后重新遍历轻儿子，加入其影响
    {
        if (u == son[v] || u == fa)
            continue;
        for (int i = L[u]; i <= R[u]; i++)	// 每棵子树内的dfs序都是连续区间
        {
            int x = id[i];	// 从dfs序反向获取结点编号
            if (!s[c[x]])	// 加入子结点对集合的贡献
                s[c[x]] = 1, ++cnt;
        }
    }
    ans[v] = cnt;	// 记录结点答案

    if (!keep)	// 即将从轻儿子返回，消去其对集合的影响
    {
        for (int i = L[v]; i <= R[v]; i++)
            s[c[id[i]]] = 0;
        cnt = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n;
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    dfs1(1, 0);
    dfs2(1, 0, 1);
    cin >> m;
    while (m--)
    {
        int v;
        cin >> v;
        cout << ans[v] << "\n";
    }

    return 0;
}

CF600E - Lomsat gelral

题目链接

题意：给定一棵树，树上每个结点有颜色 $C_i$ ，对以每个结点为根的子树，求其中出现次数最多的颜色的编号的和。

思路：
启发式合并，与上一题几乎一样，由于需要记录出现次数，可以使用map，此外需要在合并时手动更新答案。这里我们需要注意，如果你交换了两个集合，显然集合产生的出现次数最值和答案也是需要交换的，所以dfs可以顺便返回子结点情况。

树上启发式合并，思路基本一致，遍历轻儿子时根据计数情况更新答案，不要忘记加入根结点贡献。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int c[MAXN];
int64_t ans[MAXN];
vector<int> G[MAXN];
map<int, int> mp[MAXN];

pair<int64_t, int> dfs(int v, int fa)
{
    mp[v][c[v]] = 1;
    int mx = 1;
    int64_t sum = c[v];
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        auto p = dfs(u, v);
        if (mp[v].size() < mp[u].size())
        {
            swap(mp[v], mp[u]);
            mx = p.second, sum = p.first;
        }
        for (auto [color, cnt] : mp[u])
        {
            mp[v][color] += cnt;
            if (mp[v][color] > mx)
                mx = mp[v][color], sum = color;
            else if (mp[v][color] == mx)
                sum += color;
        }
        mp[u].clear();
    }
    ans[v] = sum;
    return {sum, mx};
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs(1, 0);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << " \n"[i == n];

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int sz[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int c[MAXN], mp[MAXN], mxcnt;
int64_t ans[MAXN], sum;
vector<int> G[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void dfs2(int v, int fa, bool keep)
{
    for (auto u : G[v])
        if (u != son[v] && u != fa)
            dfs2(u, v, 0);
    if (son[v])
        dfs2(son[v], v, 1);

    ++mp[c[v]];
    if (mp[c[v]] > mxcnt)
        mxcnt = mp[c[v]], sum = c[v];
    else if (mp[c[v]] == mxcnt)
        sum += c[v];
    for (auto u : G[v])
    {
        if (u == son[v] || u == fa)
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i];
            ++mp[c[x]];
            if (mp[c[x]] > mxcnt)
                mxcnt = mp[c[x]], sum = c[x];
            else if (mp[c[x]] == mxcnt)
                sum += c[x];
        }
    }
    ans[v] = sum;

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[c[id[i]]] = 0;
        mxcnt = 0, sum = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs1(1, 0);
    dfs2(1, 0, 1);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << " \n"[i == n];

    return 0;
}

CF1009F - Dominant Indices

题目链接

题意：给定一棵树，设 $d (u, x)$ 为 $u$ 子树中到 $u$ 距离为 $x$ 的结点数。对以每个点为根的子树，求最小的 $k$ 使得 $d (u, k)$ 最大。

思路：
启发式合并，用map记录子树中所有深度的结点数，合并时更新答案即可，同样地，如果交换了集合，答案也是需要交换的。

树上启发式合并，还是一样，把map换成数组。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e6 + 5;
int dep[MAXN], ans[MAXN];
vector<int> G[MAXN];
map<int, int> mp[MAXN];

pair<int, int> dfs(int v, int fa)
{
    dep[v] = dep[fa] + 1;
    mp[v][dep[v]] = 1;
    int mxcnt = 1, mndep = dep[v];
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        auto p = dfs(u, v);
        if (mp[v].size() < mp[u].size())
        {
            swap(mp[v], mp[u]);
            mxcnt = p.first, mndep = p.second;
        }
        for (auto [h, cnt] : mp[u])
        {
            mp[v][h] += cnt;
            if (mp[v][h] > mxcnt)
                mxcnt = mp[v][h], mndep = h;
            else if (mp[v][h] == mxcnt && h < mndep)
                mndep = h;
        }
    }
    ans[v] = mndep - dep[v];
    return {mxcnt, mndep};
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1, v, u; i < n; i++)
    {
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs(1, 0);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << "\n";

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e6 + 5;
int sz[MAXN], dep[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int mp[MAXN], ans[MAXN], mxcnt, mndep;
vector<int> G[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    dep[v] = dep[fa] + 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void dfs2(int v, int fa, bool keep)
{
    for (auto u : G[v])
        if (u != son[v] && u != fa)
            dfs2(u, v, 0);
    if (son[v])
        dfs2(son[v], v, 1);

    ++mp[dep[v]];
    if (mp[dep[v]] > mxcnt)
        mxcnt = mp[dep[v]], mndep = dep[v];
    else if (mp[dep[v]] == mxcnt)
        mndep = dep[v];
    for (auto u : G[v])
    {
        if (u == son[v] || u == fa)
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i];
            ++mp[dep[x]];
            if (mp[dep[x]] > mxcnt)
                mxcnt = mp[dep[x]], mndep = dep[x];
            else if (mp[dep[x]] == mxcnt && dep[x] < mndep)
                mndep = dep[x];
        }
    }
    ans[v] = mndep - dep[v];

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[dep[id[i]]] = 0;
        mxcnt = 0, mndep = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1, v, u; i < n; i++)
    {
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs1(1, 0);
    dfs2(1, 0, 1);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << "\n";

    return 0;
}

CF570D - Tree Requests

题目链接

题意：给定一棵树，每个结点有小写字母 $ch_i$ 。每次询问某个结点为根的子树中，某一深度上的所有子结点所带字母重排后能否形成回文串。

思路：显然一个字符串任意重排后若能形成回文串，最多只能有一种字符出现奇数次。考虑本题的暴力解法，大力统计每个结点为根的子树中，所有深度的结点分别对应的字符出现次数，即用map统计<深度,结果>（树上启发式合并无非是将map换成数组）。运算可以用异或简化，因为出现奇数次的字符异或为1，偶数为0。对于询问，离线后挂到结点的vector上即可。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 5e5 + 5;
char c[MAXN];
int dep[MAXN], ans[MAXN];
vector<int> G[MAXN];
vector<pair<int, int>> q[MAXN];
map<int, bitset<32>> mp[MAXN];

void dfs(int v, int fa)
{
    dep[v] = dep[fa] + 1;
    mp[v][dep[v]][c[v]] = 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs(u, v);
        if (mp[v].size() < mp[u].size())
            swap(mp[v], mp[u]);
        for (const auto &[h, bs] : mp[u])
            mp[v][h] ^= bs;
        mp[u].clear();
    }
    for (auto [k, id] : q[v])
        ans[id] = mp[v][k].count() <= 1;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 2, p; i <= n; i++)
        cin >> p, G[p].push_back(i);
    string s;
    cin >> s;
    for (int i = 1; i <= n; i++)
        c[i] = s[i - 1] - 'a';
    for (int i = 0; i < m; i++)
    {
        int v, k;
        cin >> v >> k, q[v].emplace_back(k, i);
    }
    dfs(1, 0);
    for (int i = 0; i < m; i++)
        cout << (ans[i] ? "Yes\n" : "No\n");

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 5e5 + 5;
int sz[MAXN], dep[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int c[MAXN], ans[MAXN];
bitset<32> mp[MAXN];
vector<int> G[MAXN];
vector<pair<int, int>> q[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    dep[v] = dep[fa] + 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void dfs2(int v, bool keep)
{
    for (auto u : G[v])
        if (u != son[v])
            dfs2(u, 0);
    if (son[v])
        dfs2(son[v], 1);

    mp[dep[v]].flip(c[v]);
    for (auto u : G[v])
    {
        if (u == son[v])
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i];
            mp[dep[x]].flip(c[x]);
        }
    }
    for (auto [k, id] : q[v])
        ans[id] = mp[k].count() <= 1;

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[dep[id[i]]].reset();
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 2, p; i <= n; i++)
        cin >> p, G[p].push_back(i);
    string s;
    cin >> s;
    for (int i = 1; i <= n; i++)
        c[i] = s[i - 1] - 'a';
    for (int i = 0; i < m; i++)
    {
        int v, k;
        cin >> v >> k, q[v].emplace_back(k, i);
    }
    dfs1(1, 0);
    dfs2(1, 1);
    for (int i = 0; i < m; i++)
        cout << (ans[i] ? "Yes\n" : "No\n");

    return 0;
}

CF208E - Blood Cousins

题目链接

题意：给定若干棵树，每次询问一个点与多少个点有公共k级祖先。

思路：显然处理每棵树互不干扰（注意，如果让前一棵树根的影响保留在数组中，处理其他树会出错）。一个点与多少个点有公共k级祖先，等价于这个k级祖先 $v$ 子树中深度为 $d e p [v] + k$ 的结点数减一。可以跑树上倍增把每个询问挂到其k级祖先上，直接在祖先上处理询问。记录所有深度对应的结点数，然后启发式合并即可。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int dep[MAXN], father[MAXN][20], lg[MAXN], ans[MAXN];
vector<int> G[MAXN], rt;
vector<pair<int, int>> q[MAXN], qry[MAXN];
map<int, int> mp[MAXN];

void dfs1(int v, int fa)
{
    father[v][0] = fa;
    dep[v] = dep[fa] + 1;
    for (int i = 1; i <= lg[dep[v]]; i++)
        father[v][i] = father[father[v][i - 1]][i - 1];
    for (auto u : G[v])
        dfs1(u, v);
}

int mv(int v, int k)
{
    for (int i = 0; i < 20; i++)
        if (k & (1 << i))
            v = father[v][i];
    return v;
}

void dfs2(int v)
{
    mp[v][dep[v]] = 1;
    for (auto u : G[v])
    {
        dfs2(u);
        if (mp[v].size() < mp[u].size())
            swap(mp[v], mp[u]);
        for (auto [dep, cnt] : mp[u])
            mp[v][dep] += cnt;
    }
    for (auto [k, id] : q[v])
    {
        auto p = mv(v, k);
        qry[p].emplace_back(v, id);
    }
    for (auto [u, id] : qry[v])
        ans[id] = mp[v][dep[u]] - 1;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n;
    for (int i = 1; i <= n; ++i)
        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    for (int i = 1, p; i <= n; i++)
    {
        cin >> p;
        if (p == 0)
            rt.push_back(i);
        else
            G[p].push_back(i);
    }
    cin >> m;
    for (int i = 0, v, p; i < m; i++)
    {
        cin >> v >> p;
        q[v].emplace_back(p, i);
    }
    for (auto v : rt)
        dfs1(v, 0), dfs2(v);
    for (int i = 0; i < m; i++)
        cout << ans[i] << " \n"[i + 1 == m];

    return 0;
}

参考代码（树上启发式合并)：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int sz[MAXN], dep[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int father[MAXN][20], lg[MAXN];
int c[MAXN], mp[MAXN], ans[MAXN];
vector<int> G[MAXN], rt;
vector<pair<int, int>> q[MAXN], qry[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    dep[v] = dep[fa] + 1;
    father[v][0] = fa;
    for (int i = 1; i <= lg[dep[v]]; i++)
        father[v][i] = father[father[v][i - 1]][i - 1];
    for (auto u : G[v])
    {
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

int mv(int v, int k)
{
    for (int i = 0; i < 20; i++)
        if (k & (1 << i))
            v = father[v][i];
    return v;
}

void dfs2(int v, bool keep)
{
    for (auto u : G[v])
        if (u != son[v])
            dfs2(u, 0);
    if (son[v])
        dfs2(son[v], 1);

    ++mp[dep[v]];
    for (auto u : G[v])
    {
        if (u == son[v])
            continue;
        for (int i = L[u]; i <= R[u]; i++)
            ++mp[dep[id[i]]];
    }
    for (auto [k, id] : q[v])
    {
        auto p = mv(v, k);
        qry[p].emplace_back(v, id);
    }
    for (auto [u, id] : qry[v])
        ans[id] = mp[dep[u]] - 1;

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[dep[id[i]]] = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n;
    for (int i = 1; i <= n; ++i)
        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    for (int i = 1, p; i <= n; i++)
    {
        cin >> p;
        if (p == 0)
            rt.push_back(i);
        else
            G[p].push_back(i);
    }
    cin >> m;
    for (int i = 0, v, p; i < m; i++)
    {
        cin >> v >> p;
        q[v].emplace_back(p, i);
    }
    for (auto v : rt)
        dfs1(v, 0), dfs2(v, 0); // 多棵树，你不能保留根对mp数组影响
    for (int i = 0; i < m; i++)
        cout << ans[i] << " \n"[i + 1 == m];

    return 0;
}

CF246E - Blood Cousins Return

题目链接

题意：给定若干棵树，每个结点有一个字符串代表结点名，每次询问某个结点为根的子树中，所有深度为根结点深度加k的结点有多少不同结点名。

思路：暴力做法是大力统计每个结点为根的子树中，所有深度的结点对应的名字种数，这可以通过map套set完成，使用启发式合并优化，答案就是对应深度map的size（但是询问深度可能超过树高）。如果你还想优化，也许可以用trie或哈希之类的进行字符串映射，但是暴力已经可以通过。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int dep[MAXN], ans[MAXN];
vector<int> G[MAXN], rt;
vector<pair<int, int>> q[MAXN];
map<int, set<string>> mp[MAXN];
string name[MAXN];

void dfs(int v, int fa)
{
    dep[v] = dep[fa] + 1;
    mp[v][dep[v]].insert(name[v]);
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs(u, v);
        if (mp[v].size() < mp[u].size())
            swap(mp[v], mp[u]);
        for (auto [dep, s] : mp[u])
            mp[v][dep].merge(s);
    }
    for (auto [k, id] : q[v])
    {
        k += dep[v];
        ans[id] = mp[v][k].size();
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n;
    for (int i = 1, p; i <= n; i++)
    {
        cin >> name[i] >> p;
        if (p == 0)
            rt.push_back(i);
        else
            G[p].push_back(i);
    }
    cin >> m;
    for (int i = 0, v, k; i < m; i++)
    {
        cin >> v >> k;
        q[v].emplace_back(k, i);
    }
    for (auto v : rt)
        dfs(v, 0);
    for (int i = 0; i < m; i++)
        cout << ans[i] << "\n";

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int sz[MAXN], dep[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int ans[MAXN];
set<string> mp[MAXN];
vector<int> G[MAXN], rt;
vector<pair<int, int>> q[MAXN];
string name[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    dep[v] = dep[fa] + 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void dfs2(int v, bool keep)
{
    for (auto u : G[v])
        if (u != son[v])
            dfs2(u, 0);
    if (son[v])
        dfs2(son[v], 1);

    mp[dep[v]].insert(name[v]);
    for (auto u : G[v])
    {
        if (u == son[v])
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i];
            mp[dep[x]].insert(name[x]);
        }
    }
    for (auto [k, id] : q[v])
    {
        k += dep[v];
        ans[id] = (k < MAXN ? mp[k].size() : 0); // 神坑，深度可能越界
    }

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[dep[id[i]]].erase(name[id[i]]);
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n;
    for (int i = 1, p; i <= n; i++)
    {
        cin >> name[i] >> p;
        if (p == 0)
            rt.push_back(i);
        else
            G[p].push_back(i);
    }
    cin >> m;
    for (int i = 0, v, k; i < m; i++)
    {
        cin >> v >> k;
        q[v].emplace_back(k, i);
    }
    for (auto v : rt)
        dfs1(v, 0), dfs2(v, 0);
    for (int i = 0; i < m; i++)
        cout << ans[i] << "\n";

    return 0;
}

CF375D - Tree and Queries

题目链接

题意：给定一棵树，每个结点有颜色 $C_i$ ，每次询问某个结点为根的子树中出现次数不少于 $k$ 的颜色有多少种。

思路：将询问离线挂到结点上，使用启发式合并求出每个结点为根的子树中所有颜色出现次数后，问题在于如何快速求出出现次数不少于k的颜色数，这可以通过平衡树来解决，因为这是一个经典的查排名问题，虽然pbds提供的红黑树有这个功能，但是常数过大会T，而手写的treap可以胜任。如果用树上启发式合并，实际上更好解决，额外维护一个cnt数组记录出现次数不少于k的颜色数，显然加入每个点的贡献时都会更新数组，清空时不要memset，清空到当前最大计数即可。

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int c[MAXN], ans[MAXN];
vector<int> G[MAXN];
vector<pair<int, int>> q[MAXN];
map<int, int> mp[MAXN];

struct FHQTreap
{
    struct Node
    {
        int ls, rs;
        int key, pri;
        int size;
        Node(int _ls = 0, int _rs = 0, int _key = 0, int _size = 0) : ls(_ls), rs(_rs), key(_key), pri(rand()), size(_size) {}
    };
    int tot = 0, root = 0, size = 0;
    vector<Node> t;
    void newNode(int x)
    {
        if (t.empty())
            t.emplace_back(0, 0, 0, 0);
        ++tot;
        t.emplace_back(0, 0, x, 1);
    }
    void pushUp(int u) { t[u].size = t[t[u].ls].size + t[t[u].rs].size + 1; }
    void split(int u, int x, int &l, int &r)
    {
        if (u == 0)
        {
            l = r = 0;
            return;
        }
        if (t[u].key <= x)
            l = u, split(t[u].rs, x, t[u].rs, r);
        else
            r = u, split(t[u].ls, x, l, t[u].ls);
        pushUp(u);
    }
    int merge(int l, int r)
    {
        if (l == 0 || r == 0)
            return l + r;
        if (t[l].pri > t[r].pri)
        {
            t[l].rs = merge(t[l].rs, r);
            pushUp(l);
            return l;
        }
        else
        {
            t[r].ls = merge(l, t[r].ls);
            pushUp(r);
            return r;
        }
    }
    void insert(int x)
    {
        ++size;
        int l, r;
        split(root, x, l, r);
        newNode(x);
        int p = merge(l, tot);
        root = merge(p, r);
    }
    void erase(int x)
    {
        --size;
        int l, r, p;
        split(root, x, l, r);
        split(l, x - 1, l, p);
        p = merge(t[p].ls, t[p].rs);
        root = merge(merge(l, p), r);
    }
    int rank(int x)
    {
        int l, r;
        split(root, x - 1, l, r);
        auto res = t[l].size + 1;
        root = merge(l, r);
        return res;
    }
    void clear() { tot = root = size = 0, t.clear(); }
} tr[MAXN];

void dfs(int v, int fa)
{
    mp[v][c[v]] = 1;
    tr[v].insert(1);
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs(u, v);
        if (mp[v].size() < mp[u].size())
            swap(mp[v], mp[u]), swap(tr[v], tr[u]);
        for (auto [color, val] : mp[u])
        {
            if (mp[v].count(color))
                tr[v].erase(mp[v][color]);
            mp[v][color] += val;
            tr[v].insert(mp[v][color]);
        }
        mp[u].clear(), tr[u].clear();
    }
    for (auto [k, id] : q[v])
        ans[id] = tr[v].size - tr[v].rank(k) + 1;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1, v, u; i < n; i++)
    {
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    for (int i = 0, v, k; i < m; i++)
        cin >> v >> k, q[v].emplace_back(k, i);
    dfs(1, 0);
    for (int i = 0; i < m; i++)
        cout << ans[i] << "\n";

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int sz[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int c[MAXN], mp[MAXN], ans[MAXN], cnt[MAXN], mxcnt;
vector<int> G[MAXN];
vector<pair<int, int>> q[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void dfs2(int v, int fa, bool keep)
{
    for (auto u : G[v])
        if (u != son[v] && u != fa)
            dfs2(u, v, 0);
    if (son[v])
        dfs2(son[v], v, 1);

    ++mp[c[v]], ++cnt[mp[c[v]]], mxcnt = max(mxcnt, mp[c[v]]);
    for (auto u : G[v])
    {
        if (u == son[v] || u == fa)
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i];
            ++mp[c[x]], ++cnt[mp[c[x]]], mxcnt = max(mxcnt, mp[c[x]]);
        }
    }
    for (auto [k, id] : q[v])
        ans[id] = cnt[k];

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[c[id[i]]] = 0;
        fill(cnt, cnt + mxcnt + 1, 0);
        mxcnt = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1, v, u; i < n; i++)
    {
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    for (int i = 0, v, k; i < m; i++)
        cin >> v >> k, q[v].emplace_back(k, i);
    dfs1(1, 0);
    dfs2(1, 0, 1);
    for (int i = 0; i < m; i++)
        cout << ans[i] << "\n";

    return 0;
}

2020 CCPC Wannafly Winter Camp Day2 阔力梯的树

题目链接

题意：给定一棵树，定义每个点的答案为以其为根的子树中，所有结点编号从小到大排序后，各相邻两项的差的平方和，即 $\sum_{i=1}^{k-1}\left(a_{i+1}-a_i\right)^2$ 。

解析：使用启发式合并求出每个点为根的子树的编号集合，与其每次暴力遍历集合求答案，不如在合并时一边逐个加入小集合中的编号，一边对当前加入的编号，增加它对前驱和后继的贡献，并减去前驱和后继二者之间的贡献，注意判断没有前驱或者后继的情况。本题必须用set，所以不妨直接写双log法。

参考代码：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
vector<int> G[MAXN];
set<int> s[MAXN];
int64_t ans[MAXN];

int64_t dfs(int v)
{
    int64_t sum = 0;
    s[v].insert(v);
    for (auto u : G[v])
    {
        auto res = dfs(u);
        if (s[v].size() < s[u].size())
            swap(s[v], s[u]), sum = res;
        for (auto num : s[u])
        {
            int mid = 0;
            auto it1 = s[v].insert(num).first, it2 = it1;
            if (it1 != s[v].begin())
                --it1, sum += 1ll * (num - *it1) * (num - *it1), ++mid;
            if (++it2 != s[v].end())
                sum += 1ll * (num - *it2) * (num - *it2), ++mid;
            if (mid == 2)
                sum -= 1ll * (*it1 - *it2) * (*it1 - *it2);
        }
        s[u].clear();
    }
    ans[v] = sum;
    return sum;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 2, p; i <= n; i++)
        cin >> p, G[p].push_back(i);
    dfs(1);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << "\n";

    return 0;
}

CSP202212-4 聚集方差

题目链接

题意：给定一棵树，每个点有权值 $a_i$ ，求以每个结点为根的子树的聚集方差值。聚集方差定义为，对于一个可重集中的所有元素，分别找到权值最接近的元素，作差后平方并累加至答案中。如可重集 ${0,1,1,3\}$ 中， $< 0, 1 >$ , $< 1, 1 >$ , $< 1, 1 >$ , $< 3, 1 >$ 分别产生 $1, 0, 0, 4$ 的贡献。

思路：比较明显的启发式合并，麻烦之处在于合并时重新计算贡献。对于每个新加入的元素 $v$ ，显然要找到其前驱 $p re$ 和后继 $s u c$ ， $v$ 的贡献在其中产生，注意判断没有前驱或后继的情况。对于前驱 $p re$ 和后继 $s u c$ ，要减去其原本带来的贡献，那么还要判断 $p re$ 是否有前驱， $s u c$ 是否有后继，然后重新加上 $p re$ 和 $s u c$ 的新贡献。总而言之就是十分麻烦。和上一题同样的原因，直接写双log法即可。

参考代码：

#include 
using namespace std;

using iter = multiset<int>::iterator;
constexpr int MAXN = 3e5 + 5;
vector<int> G[MAXN];
multiset<int> s[MAXN];
int64_t ans[MAXN];

int64_t cal(const multiset<int> &ms, iter p)
{
    if (p == ms.begin())
    {
        auto suc = next(p);
        return 1ll * (*p - *suc) * (*p - *suc);
    }
    else if (next(p) == ms.end())
    {
        auto pre = prev(p);
        return 1ll * (*p - *pre) * (*p - *pre);
    }
    auto pre = prev(p), suc = next(p);
    auto mn = min(abs(*pre - *p), abs(*suc - *p));
    return 1ll * mn * mn;
}

int64_t dfs(int v)
{
    int64_t sum = 0;
    for (auto u : G[v])
    {
        auto res = dfs(u);
        if (s[v].size() < s[u].size())
            swap(s[v], s[u]), sum = res;
        for (auto num : s[u])
        {
            auto p = s[v].insert(num), it1 = p, it2 = next(p);
            sum += cal(s[v], p);
            if (it1 != s[v].begin())
            {
                --it1;
                int64_t mn = 1e18;
                if (it1 != s[v].begin())
                {
                    auto tmp = prev(it1);
                    mn = 1ll * (*tmp - *it1) * (*tmp - *it1);
                }
                auto tmp = next(p);
                if (tmp != s[v].end())
                    mn = min(mn, 1ll * (*tmp - *it1) * (*tmp - *it1));
                if (mn != 1e18)
                    sum -= mn;
                sum += cal(s[v], it1);
            }
            if (it2 != s[v].end())
            {
                int64_t mn = 1e18;
                auto tmp = next(it2);
                if (tmp != s[v].end())
                    mn = 1ll * (*tmp - *it2) * (*tmp - *it2);
                tmp = it1;
                if (p != s[v].begin())
                    mn = min(mn, 1ll * (*tmp - *it2) * (*tmp - *it2));
                if (mn != 1e18)
                    sum -= mn;
                sum += cal(s[v], it2);
            }
        }
        s[u].clear();
    }
    ans[v] = sum;
    return sum;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 2, p; i <= n; i++)
        cin >> p, G[p].push_back(i);
    for (int i = 1, x; i <= n; i++)
        cin >> x, s[i].insert(x);
    dfs(1);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << "\n";

    return 0;
}

2022 CCPC女生赛 L. 彩色的树

题目链接

题意：给定一棵树，每个点有颜色 $C_i$ ，每次询问某个结点为根的子树內，与根距离不超过k的点中，一共有多少种颜色。k是定值。

思路：
方法一，线段树合并。可以想到，每个点都会对它的1到k级祖先产生贡献（当然对自己也有贡献），这符合树上差分的性质，那么就可以利用线段树合并，自底向上快速求出每个结点的所有颜色计数情况。在权值线段树中再额外维护一个属性，统计所有计数不为0的单点的数量，即为答案。

方法二，启发式合并。整体思路依旧是利用树上差分，只是将权值线段树换为map，合并后计数为0的点需要删去，map的size即为答案。

方法三，树上启发式合并，遍历轻儿子的过程中，我们很容易想到只需要遍历前 $k$ 层的子结点即可，问题在于重儿子的贡献只能保留 $k$ 层如何实现，考虑到每个结点在 $k + 1$ 级祖先处被消除贡献后，更高级的祖先都不会持有该贡献，因此我们跑倍增求出每个结点的 $k + 1$ 级祖先，将结点编号加入祖先的vector里，到时消除即可。但是，我们无法区分vector中的哪些点属于重儿子所在子树，这可能导致我们多消除一些贡献。因此轻儿子可以改为遍历前 $k + 1$ 层结点，然后统一消去第 $k + 1$ 层的所有结点贡献，无论轻重。

参考代码（线段树合并）：

#include 
using namespace std;

#define ls tr[rt].lc
#define rs tr[rt].rc
constexpr int MAXN = 1e5 + 5;
struct Node
{
    int lc, rc;
    int val, cnt;
} tr[MAXN << 5];
int n, m, k;
int tp[MAXN], tot;
int dep[MAXN], father[MAXN][20], lg[MAXN];
int c[MAXN], ans[MAXN];
vector<int> G[MAXN];

void pushUp(int rt)
{
    tr[rt].val = tr[ls].val + tr[rs].val;
    tr[rt].cnt = tr[ls].cnt + tr[rs].cnt;
}

void add(int rt, int val, int C, int l, int r)
{
    if (l == r)
    {
        tr[rt].val += C;
        tr[rt].cnt = (tr[rt].val > 0);
        return;
    }
    int mid = (l + r) >> 1;

    if (val <= mid)
    {
        if (!ls) ls = ++tot;
        add(ls, val, C, l, mid);
    }
    else
    {
        if (!rs) rs = ++tot;
        add(rs, val, C, mid + 1, r);
    }
    pushUp(rt);
}

int merge(int p, int q, int l, int r)
{
    if (!p || !q)
        return p + q;
    if (l == r)
    {
        tr[p].val += tr[q].val;
        tr[p].cnt = (tr[p].val > 0);
        return p;
    }
    int mid = (l + r) >> 1;

    tr[p].lc = merge(tr[p].lc, tr[q].lc, l, mid);
    tr[p].rc = merge(tr[p].rc, tr[q].rc, mid + 1, r);
    pushUp(p);
    return p;
}

int query(int rt, int L, int R, int l, int r)
{
    if (L <= l && r <= R)
        return tr[rt].cnt;
    int mid = (l + r) >> 1;

    int res = 0;
    if (L <= mid)
        res += query(ls, L, R, l, mid);
    if (R > mid)
        res += query(rs, L, R, mid + 1, r);
    return res;
}

void dfs1(int v, int fa)
{
    tp[v] = ++tot;
    father[v][0] = fa;
    dep[v] = dep[fa] + 1;
    for (int i = 1; i <= lg[dep[v]]; i++)
        father[v][i] = father[father[v][i - 1]][i - 1];
    for (auto u : G[v])
        if (u != fa)
            dfs1(u, v);
}

int mv(int v, int k)
{
    for (int i = 19; i >= 0; i--)
        if (k & (1 << i))
            v = father[v][i];
    return v;
}

void dfs2(int v, int fa)
{
    for (auto u : G[v])
    {
        if (u != fa)
            dfs2(u, v), merge(tp[v], tp[u], 1, n);
    }
    auto p = mv(v, k + 1);
    add(tp[v], c[v], 1, 1, n);
    if (p != 0)
        add(tp[p], c[v], -1, 1, n);
    ans[v] = query(tp[v], 1, n, 1, n);
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> k;
    for (int i = 1; i <= n; ++i)
        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs1(1, 0);
    dfs2(1, 0);
    cin >> m;
    while (m--)
    {
        int x;
        cin >> x;
        cout << ans[x] << "\n";
    }

    return 0;
}

参考代码（启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int n, m, k;
int dep[MAXN], father[MAXN][20], lg[MAXN];
int c[MAXN], ans[MAXN];
vector<int> G[MAXN];
map<int, int> mp[MAXN];

void dfs1(int v, int fa)
{
    father[v][0] = fa;
    dep[v] = dep[fa] + 1;
    for (int i = 1; i <= lg[dep[v]]; i++)
        father[v][i] = father[father[v][i - 1]][i - 1];
    for (auto u : G[v])
        if (u != fa)
            dfs1(u, v);
}

int mv(int v, int k)
{
    for (int i = 19; i >= 0; i--)
        if (k & (1 << i))
            v = father[v][i];
    return v;
}

void dfs2(int v, int fa)
{
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs2(u, v);
        vector<int> del;
        if (mp[v].size() < mp[u].size())
            swap(mp[v], mp[u]);
        for (auto [color, cnt] : mp[u])
        {
            mp[v][color] += cnt;
            if (mp[v][color] == 0)
                del.push_back(color);
        }
        for (auto color : del)
            mp[v].erase(color);
    }
    auto p = mv(v, k + 1);
    ++mp[v][c[v]], --mp[p][c[v]];
    ans[v] = mp[v].size();
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> k;
    for (int i = 1; i <= n; ++i)
        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs1(1, 0);
    dfs2(1, 0);
    cin >> m;
    while (m--)
    {
        int x;
        cin >> x;
        cout << ans[x] << "\n";
    }

    return 0;
}

参考代码（树上启发式合并）：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int n, m, k;
int sz[MAXN], dep[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int father[MAXN][20], lg[MAXN];
int c[MAXN], mp[MAXN], ans[MAXN], cnt;
vector<int> G[MAXN], del[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    dep[v] = dep[fa] + 1;
    father[v][0] = fa;
    for (int i = 1; i <= lg[dep[v]]; i++)
        father[v][i] = father[father[v][i - 1]][i - 1];
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

int mv(int v, int k)
{
    for (int i = 19; i >= 0; i--)
        if (k & (1 << i))
            v = father[v][i];
    return v;
}

void dfs2(int v, int fa, bool keep)
{
    for (auto u : G[v])
        if (u != son[v] && u != fa)
            dfs2(u, v, 0);
    if (son[v])
        dfs2(son[v], v, 1);

    del[mv(v, k + 1)].push_back(v);
    if (++mp[c[v]] == 1)
        ++cnt;
    for (auto u : G[v])
    {
        if (u == son[v] || u == fa)
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i];
            if (dep[x] - dep[v] <= k + 1)
            {
                if (++mp[c[x]] == 1)
                    ++cnt;
            }
        }
    }
    for (auto u : del[v])
    {
        if (--mp[c[u]] == 0)
            --cnt;
    }
    ans[v] = cnt;

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[c[id[i]]] = 0;
        cnt = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> k;
    for (int i = 1; i <= n; ++i)
        lg[i] = lg[i - 1] + (1 << lg[i - 1] == i);
    for (int i = 1; i <= n; i++)
        cin >> c[i];
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs1(1, 0);
    dfs2(1, 0, 1);
    cin >> m;
    while (m--)
    {
        int x;
        cin >> x;
        cout << ans[x] << "\n";
    }

    return 0;
}

CF1709E - XOR Tree

题目链接

题意：给定一棵树，每个结点有权值 $a_i$ ，可以进行任意次操作，每次操作将一个点的权值更换为任意正整数，求最小操作次数，使得任意两点路径异或和不为0。

思路：注意观察本题操作性质，可以任意更换权值，那么我们一定可以使得一个点的权值被更换后，所有经过它的路径异或和均不为0。由此我们得到一个贪心思想，以一个点为根的子树中，如果有经过根的路径异或和为0，则只需要对根结点操作一次，这个贪心过程是自底向上检查的。于是问题转换为如何快速支持查询。固定整个树根为1，令 $XOR [p]$ 表示从1到 $p$ 的路径异或和。设以 $v$ 为根的子树中，存在点 $x, y$ 使得 $x - v - y$ 的路径异或和为0，则满足 $\oplus XOR[y] \oplus a[v] == 0$ 。
这是一个经典的问题，我们只需要用 $se t [v]$ 记录当前已经遍历的 $v$ 的子树中，所有结点的 $XOR [c hi l d]$ 值，对于新遍历的子树，枚举其 $se t [u]$ 中所有值 $v a l$ ，若 $se t [v]$ 中存在 $\oplus val$ ，则存在异或和为0的路径，说明我们需要对 $v$ 使用一次操作，则 $v$ 所在子树内的所有结点都不会与整棵树上的其他结点形成异或和为0的路径，因此 $se t [v]$ 相当于被清空。这个过程可以使用启发式合并优化。

由于 $a_i$ 范围达到 $2^{30}$ ，需要使用set，因此直接写双log法更方便。

参考代码：

#include 
using namespace std;

constexpr int MAXN = 2e5 + 5;
vector<int> G[MAXN];
int a[MAXN], XOR[MAXN], ans;
set<int> s[MAXN];

void dfs(int v, int fa)
{
    XOR[v] = XOR[fa] ^ a[v];
    s[v].insert(XOR[v]);
    bool modify = 0;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs(u, v);
        if (s[v].size() < s[u].size())
            swap(s[v], s[u]);
        for (auto val : s[u])
        {
            if (s[v].count(a[v] ^ val))
                modify = 1;
        }
        if (!modify)
            s[v].merge(s[u]);
        s[u].clear();
    }
    if (modify)
        s[v].clear(), ++ans;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    for (int i = 1; i < n; i++)
    {
        int v, u;
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs(1, 0);
    cout << ans << endl;

    return 0;
}

*CF741D - Arpa’s letter-marked tree and Mehrdad’s Dokhtar-kosh paths

题目链接

题意：给定一棵树，每条树边上有小写字母 $ch_i$ ，求每个结点为根的子树中最长的Dokhtar-kosh路径的长度。Dokhtar-kosh路径要求路径上的字符重排后可形成回文串。

思路：与上一题整体思路大同小异，同时也可认为是 CF570D - Tree Requests 的加强版。首先可以将边权下放至点权，即令深度更大的结点带上边权值，并预处理出根到每个点的路径异或和。考虑子树如何给根带来贡献，显然根的答案可以对子树答案取max，这是不经过根的路径；对于经过根的路径，同上一题一样，使用启发式合并维护map以快速查询，map中保存各个异或值所对应的最大深度。合并时，假设当前树根为 $r t$ ，正在遍历的子树中的点为 $v$ ，枚举 $XOR [v]$ 变化每位的情况及保持不变的情况，设其值为 $v a l$ ，若能在map中找到 $v a l$ ，说明有符合的点（因为原本是边权，你并不需要再异或上 $XOR [r t]$ ），它们间的路径长就是 $d e p [v] + m p [v a l] - d e p [r t] * 2$ 。

注：本题正解就是树上启发式合并，由于题目数据范围达到 $5 e 5$ 级别，且查询复杂，不写单log法将被卡至TLE（因为你不得不使用map等数据结构，枚举变化也需要log时间，你将达到3log）。作者特别标明：

Corner case: You must use an array, no map or unordered map for bag, these solutions got TLE.
边界情况：你必须使用数组，不能使用map和unordered_map等数据结构，这些解法都会TLE。

参考代码：

#include 
using namespace std;

constexpr int MAXN = 5e5 + 5;
int dep[MAXN], sz[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int XOR[MAXN], mp[1 << 22], ans[MAXN];
vector<int> G[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    dep[v] = dep[fa] + 1;
    XOR[v] = XOR[fa] ^ XOR[v];
    for (auto u : G[v])
    {
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void dfs2(int v, bool keep)
{
    for (auto u : G[v])
        if (u != son[v])
            dfs2(u, 0), ans[v] = max(ans[v], ans[u]);
    if (son[v])
        dfs2(son[v], 1), ans[v] = max(ans[v], ans[son[v]]);

    mp[XOR[v]] = max(mp[XOR[v]], dep[v]);
    ans[v] = max(ans[v], mp[XOR[v]] - dep[v]);
    for (int i = 0; i < 22; i++)
    {
        auto val = XOR[v] ^ (1 << i);
        if (mp[val])
            ans[v] = max(ans[v], mp[val] - dep[v]);
    }

    for (auto u : G[v])
    {
        if (u == son[v])
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            auto val = XOR[id[i]], h = dep[id[i]];
            for (int j = 0; j < 22; j++)
            {
                if (mp[val ^ (1 << j)])
                    ans[v] = max(ans[v], h + mp[val ^ (1 << j)] - dep[v] * 2);
            }
            if (mp[val])
                ans[v] = max(ans[v], h + mp[val] - dep[v] * 2);
        }
        for (int i = L[u]; i <= R[u]; i++)
        {
            auto val = XOR[id[i]];
            mp[val] = max(mp[val], dep[id[i]]);
        }
    }

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            mp[XOR[id[i]]] = 0;
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 2; i <= n; i++)
    {
        int p;
        char ch;
        cin >> p >> ch;
        G[p].push_back(i), XOR[i] = 1 << (ch - 'a');
    }
    dfs1(1, 0);
    dfs2(1, 1);
    for (int i = 1; i <= n; i++)
        cout << ans[i] << " \n"[i == n];

    return 0;
}

*2020 CCPC Changchun F. Strange Memory

题目链接

题意：给定一棵树，每个点有权值 $a_i$ ，对于所有满足 $i < j i 且 a i ⊕ a j ⊕ a l c a ( i , j ) = = 0 a_i \oplus a_j \oplus a_{lca(i,j)} == 0 的有序对 ( i , j ) (i,j) ，其对答案的贡献为 i ⊕ j i \oplus j 。$

思路：显然两点间路径形态必须是 “/\” 形，而不能是直链（因为输入保证 $a_i \neq 0$ ）。通过启发式合并，我们很容易判断对于当前正在遍历的子树中的点 $u$ ，是否存在符合的点 $v$ ，以及这样的 $v$ 的数量，但问题在于如何求贡献。考虑一种暴力做法，把点丢到点权对应的vector里，这样就能大力遍历编号求异或和，理论上会被卡T，但是数据比较水（所以这题也从银牌题掉到了铜牌题）。

正解是将位拆开考虑，这在涉及位运算的题目中是一种十分常见的思想。对于符合的两个点 $v, u$ ，设其二进制位为 $v_{b_i}$ 和 $u_{b_i}$ ，显然它们对答案的贡献为 $\sum_{i=0}^{k} (1<∑i=0k(1<<i)∗(vbi⊕ubi)$

参考代码：

#include 
using namespace std;

constexpr int MAXN = 1e5 + 5;
int sz[MAXN], son[MAXN], L[MAXN], R[MAXN], id[MAXN], dfn;
int a[MAXN], mp[1 << 20][17][2];
int64_t ans;
vector<int> G[MAXN];

void dfs1(int v, int fa)
{
    L[v] = ++dfn;
    id[dfn] = v;
    sz[v] = 1;
    for (auto u : G[v])
    {
        if (u == fa)
            continue;
        dfs1(u, v);
        sz[v] += sz[u];
        if (sz[u] > sz[son[v]])
            son[v] = u;
    }
    R[v] = dfn;
}

void add(int v)
{
    auto &dst = mp[a[v]];
    for (int i = 0; i < 17; i++)
        (v & (1 << i)) ? ++dst[i][1] : ++dst[i][0];
}

void del(int v)
{
    auto &dst = mp[a[v]];
    for (int i = 0; i < 17; i++)
        (v & (1 << i)) ? --dst[i][1] : --dst[i][0];
}

void dfs2(int v, int fa, bool keep)
{
    for (auto u : G[v])
        if (u != son[v] && u != fa)
            dfs2(u, v, 0);
    if (son[v])
        dfs2(son[v], v, 1);

    add(v);
    for (auto u : G[v])
    {
        if (u == son[v] || u == fa)
            continue;
        for (int i = L[u]; i <= R[u]; i++)
        {
            int x = id[i], val = a[x];
            auto &dst = mp[val ^ a[v]];
            for (int j = 0; j < 17; j++)
                ans += (1ll << j) * dst[j][!(x & (1 << j))];
        }
        for (int i = L[u]; i <= R[u]; i++)
            add(id[i]);
    }

    if (!keep)
    {
        for (int i = L[v]; i <= R[v]; i++)
            del(id[i]);
    }
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    for (int i = 1, v, u; i < n; i++)
    {
        cin >> v >> u;
        G[v].push_back(u), G[u].push_back(v);
    }
    dfs1(1, 0);
    dfs2(1, 0, 1);
    cout << ans << endl;

    return 0;
}

总结

树上启发式合并是解决相当一类子树问题的利器，在诸多比赛题目中都有广泛的应用，能够用 $O (Nl o g N)$ 或 $O(Nlog^2N)$ 的时间复杂度解决问题，有时也可转换为线段树合并等。在绝大多数情况下， $O(Nlog^2N)$ 的写法都不会被卡，所以为了追求过题效率，可以大力双log法。

在没有思路时，牢记一句话：“提到子树，就想到树上启发式合并。”

你可能感兴趣的:(#,数据结构,数据结构,算法,树上问题,启发式合并)

基于协同过滤推荐算法的景点票务数据系统（python-计算机毕设）计算机程序设计(接毕设) 推荐算法机器学习毕业设计 python 人工智能
摘要IABSTRACTII第1章引言1研究背景及意义1研究背景1研究意义1国内外研究现状2智慧旅游3旅游大数据3研究内容4本章小结4第2章相关技术概述5基于内容的推荐算法5基于内容的推荐算法原理5基于内容的推荐算法实现5协同过滤推荐算法6协同过滤算法原理6协同过滤算法实现7SpringBoot框架9SpringBoot简介9SpringBoot特性10SpringBoot工作原理10Vue.js框
目标检测YOLO实战应用案例100讲-基于毫米波雷达与摄像头协同的道路目标检测与识别（续）林聪木目标检测 YOLO 人工智能
目录3.2实测数据采集与分析3.2.1回波数据处理3.2.2毫米波雷达数据采集实验3.3基于传统图像特征的目标识别算法3.3.1基于灰度共生矩阵的时频图特征提取3.3.2支持向量机分类器3.3.3实验及结果分析3.4基于卷积神经网络的目标识别算法3.4.1卷积神经网络的基本理论3.4.2卷积神经网络框架设计3.4.3实验及结果分析基于图像的目标检测算法4.1目标检测算法一般流程4.2典型目标检测算
C#基于MVC模式实现TCP三次握手，附带简易日志管理模块风，停下 C#设计模式网络协议 c#mvc tcp/ip
C#基于MVC模式实现TCP三次握手1Model1.1ServerModel1.2ClientModel1.3配置参数模块1.4日志管理模块1.4.1数据结构1.4.1日志管理工具类1.4.1日志视图展示1.4.1.1UcLogManage.cs1.4.1.2UcLogManage.Designer.cs2视图（View）2.1ViewServer2.1.1ViewServer.cs2.1.1Vi
JDK8 Stream 数据流效率分析，Java开发你需要了解的那些事气质大叔程序员后端面试 java
此外还有一系列特化流，如IntStream，LongStream，DoubleStream等），Java8引入的的Stream主要用于取代部分Collection的操作，每个流代表一个值序列，流提供一系列常用的聚集操作，可以便捷的在它上面进行各种运算。集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构；作为阅读福利，小编也整理了一些Java学习笔记（包含面试真题+脑图
C语言经典算法之二叉树的后序遍历（递归实现） JJJ69 C语言经典算法算法 c语言开发语言数据结构
目录前言A.建议B.简介一代码实现二时空复杂度A.时间复杂度：B.空间复杂度：三优缺点A.优点：B.缺点：四现实中的应用前言A.建议1.学习算法最重要的是理解算法的每一步，而不是记住算法。2.建议读者学习算法的时候，自己手动一步一步地运行算法。tips：文中的（如果有）对数，则均以2为底数B.简介在C语言中，二叉树的后序遍历（PostorderTraversal）是一种按照“左子树-右子树-根节点
OpenCV 图像几何变换：旋转，缩放，斜切奈何小洪 OPENCV opencv 图像旋转缩放
几何变换几何变换可以看成图像中物体（或像素）空间位置改变，或者说是像素的移动。几何运算需要空间变换和灰度级差值两个步骤的算法，像素通过变换映射到新的坐标位置，新的位置可能是在几个像素之间，即不一定为整数坐标。这时就需要灰度级差值将映射的新坐标匹配到输出像素之间。最简单的插值方法是最近邻插值，就是令输出像素的灰度值等于映射最近的位置像素，该方法可能会产生锯齿。这种方法也叫零阶插值，相应比较复杂的还有
PyTorch 深度学习实战（19）：离线强化学习与 Conservative Q-Learning (CQL) 算法进取星辰 PyTorch 深度学习实战深度学习 pytorch 算法
在上一篇文章中，我们探讨了分布式强化学习与IMPALA算法，展示了如何通过并行化训练提升强化学习的效率。本文将聚焦离线强化学习（OfflineRL）这一新兴方向，并实现ConservativeQ-Learning(CQL)算法，利用Minari提供的静态数据集训练安全的强化学习策略。一、离线强化学习与CQL原理1.离线强化学习的特点无需环境交互：直接从预收集的静态数据集学习数据效率高：复用历史经验
OpenCV旋转估计（2）用于自动检测波浪校正类型的函数autoDetectWaveCorrectKind() 村北头的码农 OpenCV opencv 人工智能计算机视觉
操作系统：ubuntu22.04OpenCV版本：OpenCV4.9IDE:VisualStudioCode编程语言：C++11算法描述cv::detail::autoDetectWaveCorrectKind是OpenCV中用于自动检测波浪校正类型的函数，它根据输入的旋转矩阵集合来决定使用哪种波浪校正模式。波浪校正（WaveCorrection）是图像拼接过程中的一部分，主要用于纠正由于相机在拍
使用fastapi部署stable diffusion模型明晚十点睡代码 fastapi stable diffusion pytorch python 人工智能深度学习计算机视觉
使用vscode运行stablediffusion模型，每次加载模型都需要10+分钟，为算法及prompt调试带来了极大麻烦。使用jupyter解决自然是一个比较好的方案，但如果jupyter由于种种原因不能使用时，fastapi无疑成为了一个很好的选择。参考github链接：https://github.com/jarvislabsai/fastapi-sd-templatefromfastap
基于51单片机设计的呼吸灯鱼弦单片机系统合集 51单片机嵌入式硬件单片机
鱼弦：公众号【红尘灯塔】，CSDN博客专家、内容合伙人、新星导师、全栈领域优质创作者、51CTO(Top红人+专家博主)、github开源爱好者（go-zero源码二次开发、游戏后端架构https://github.com/Peakchen）基于51单片机设计的呼吸灯是一种常见的LED灯效应果，通过控制LED的亮度逐渐增加和减小，模拟人类呼吸的效果。下面将对其原理、应用场景、算法实现、代码实现等进
【科大讯飞笔试题汇总】2024-04-21-科大讯飞春招笔试题-三语言题解(CPP/Python/Java) 春秋招笔试突围最新互联网春秋招试题合集 python java 开发语言春招笔试互联网大厂笔试题
大家好这里是KK爱Coding，一枚热爱算法的程序员✨本系列打算持续跟新科大讯飞近期的春秋招笔试题汇总～ACM银牌|多次AK大厂笔试｜编程一对一辅导感谢大家的订阅➕和喜欢KK这边最近正在收集近一年互联网各厂的笔试题汇总，如果有需要的小伙伴可以关注后私信一下KK领取，会在飞书进行同步的跟新，5月1日之前限时免费领取哦，后续会由ACM银牌团队持续维护~。文章目录01.硬币最少组合问题问题描述输入格式输
用指针实现数组元素循环移动 Stimpay 算法数据结构 c语言
任务描述本关任务：编写程序，用指针实现以下功能，n个整数存入一维数组中，将该数组循环左移m位。如一个长度为10的数组中原来的元素顺序为0123456789，则循环左移3个位置后元素的顺序为3456789012。相关知识为了完成本关任务，有两种算法思想：一种是使用辅助数组实现数据移动；另一种是不使用辅助数组，只需一个中间变量就可实现数据移动。使用辅助数组实现数据移动创建一个同样大小辅助数组，存放临时
一切皆是映射：DQN训练加速技术：分布式训练与GPU并行 AI天才研究院计算 AI大模型企业级应用开发实战 ChatGPT 计算科学神经计算深度学习神经网络大数据人工智能大型语言模型 AI AGI LLM Java Python 架构设计 Agent RPA
1.背景介绍1.1深度强化学习的兴起近年来，深度强化学习（DeepReinforcementLearning，DRL）在游戏、机器人控制、自然语言处理等领域取得了令人瞩目的成就。作为一种结合深度学习和强化学习的强大技术，DRL能够使智能体在与环境交互的过程中学习最优策略，从而实现自主决策和控制。1.2DQN算法及其局限性深度Q网络（DeepQ-Network，DQN）是DRL的一种经典算法，它利用
2025美团最新面试题—Java程序减少GC的设计程序员共鸣 java jvm 开发语言
1.对象复用与池化线程局部变量：通过ThreadLocal缓存线程私有对象，避免竞争。可变对象：优先使用可修改对象（如StringBuilder代替String拼接）。2.减少对象创建避免隐式装箱：使用基本类型（int而非Integer）。优化循环：避免在循环内创建临时对象。静态不可变对象：将常量声明为staticfinal（如配置参数）。3.数据结构优化预分配容量：初始化集合时指定合理大小（如A
腾讯云与MongoDB战略合作升级，瞄准AI时代的数据管理服务 CSDN资讯腾讯云 mongodb 人工智能
2025年3月20日，腾讯云与MongoDB联合宣布续签战略合作协议，双方将围绕AI时代的技术变革为全球用户提供卓越的数据管理服务。文档数据库MongoDB以其灵活的数据结构、强大的性能和原生的分布式扩展性等特点，成为最受欢迎的NoSQL数据库之一，广泛应用于游戏、社交媒体、电商、金融和物联网等各行各业。在DB-Engines全球数据库排行榜上，MongoDB长期位居NoSQL数据库第一。据了解，
List 和 Set 的区别不会搬砖的淡水鱼数据结构 list windows 数据结构
List和Set的区别在Java中，List和Set都是Collection接口的子接口，但它们的存储结构、特点、使用场景不同。对比项List（有序、可重复）Set（无序、不可重复）是否允许重复元素✅允许❌不允许是否有序✅按插入顺序排序❌无序（TreeSet除外）是否可以有null✅允许多个null✅只允许一个null底层数据结构数组、链表哈希表、红黑树访问方式通过索引访问通过iterator遍历
RSA加密算法不会搬砖的淡水鱼网络服务器安全
RSA加密算法：数学魔术背后的安全守护者RSA加密算法（Rivest-Shamir-Adleman）是一种广泛使用的公钥加密算法，它在信息安全领域具有重要作用。RSA是由罗纳德·李维斯特（RonRivest）、阿迪·萨莫尔（AdiShamir）和伦纳德·阿德曼（LeonardAdleman）在1977年一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。RS
基础算法--欧拉函数不会搬砖的淡水鱼基础算法算法 java 数据结构
欧拉函数（Euler’stotientfunction），也称为费马函数，是一个与正整数相关的数论函数，用符号φ(n)表示。欧拉函数φ(n)定义为小于或等于n的正整数中与n互质的数的个数。RSA加密算法（Rivest-Shamir-Adleman）就是通过欧拉函数进行公钥加密。具体而言，对于给定的正整数n，欧拉函数φ(n)计算满足以下条件的k的个数：1≤k≤n，且k与n互质（即k和n的最大公约数为
基础算法--背包问题不会搬砖的淡水鱼基础算法算法 java 动态规划贪心算法
背包问题概念完全背包（无限背包）0-1背包概念背包问题是一个经典的组合优化问题，其目标是在给定的一组物品中选择一些物品放入背包中，使得物品的总价值最大化，同时要求背包的总重量不超过背包的容量限制。背包问题有两种常见的变体：完全背包和0-1背包。鉴于完全背包计算过程相对0-1背包简单，这里先讲完全背包。完全背包（无限背包）在完全背包问题中，每个物品可以选择放入背包中的次数是无限的，即可以重复选择。每
CUDA编程基础清澜算法面试人工智能 c++算法 nvidia cuda编程
一、快速理解CUDA编程1.1CUDA简介CUDA（ComputeUnifiedDeviceArchitecture）是由NVIDIA推出的并行计算平台和应用程序接口模型。它允许开发者利用NVIDIAGPU的强大计算能力来加速通用计算任务，而不仅仅是图形渲染。通过CUDA，开发者可以编写C、C++或Fortran代码，并将其扩展以在GPU上运行，从而显著提高性能，特别是在处理大规模数据集和复杂算法
泛目录程序：2025快云站群程序的SEO优化功能云惠科技大数据泛目录
快云站群程序的SEO优化功能围绕搜索引擎算法设计，具体包含以下核心模块：1.关键词智能布局密度检测与优化：自动分析内容关键词密度，建议合理区间（2%-8%），避免堆砌或遗漏；多词策略支持：可针对单篇内容设置主关键词+长尾词组合，覆盖更多搜索场景；标题/摘要自动生成：根据关键词智能生成高点击率的标题和Meta描述，提升搜索展示效果。2.内链自动化系统内容关联推荐：基于语义分析，自动在文章中插入相关内
【LeetCode 热题100】 23. 合并 K 个升序链表的算法思路及python代码 pljnb LeetCode热题100 算法 leetcode 链表
23.合并K个升序链表给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。示例1：输入：lists=[[1,4,5],[1,3,4],[2,6]]输出：[1,1,2,3,4,4,5,6]解释：链表数组如下：[1->4->5,1->3->4,2->6]将它们合并到一个有序链表中得到。1->1->2->3->4->4->5->6示例2：输入：lists=[
【Leetcode刷题随笔】59 螺旋矩阵 Poor_DayDreamer leetcode数组篇 Medium Tag leetcode 矩阵算法
1.题目描述给定一个正整数n，生成一个包含1到n2所有元素，且元素按顺时针顺序螺旋排列的nxn正方形矩阵matrix。可结合以下原题链接阅读。原题链接：59螺旋矩阵2.解题思路本题为模拟矩阵填充过程，不需要设计算法，只要完成正确的填充过程即可。首先初始化一个nxn的二维矩阵（涉及到动态内存分配），从矩阵左上角开始往顺时针填充，关键在于填充的转角处不要重复填充，所以对于每条边都要遵循严格的统一规则，
算法入门——二分法 Able Zhao 650829 算法数据结构 c++蓝桥杯
二分法真的很容易出错！！！在用dp学习之后总结了一下二分法二分查找关键总结一、核心思想分治策略：每次将搜索范围缩小一半，适用于有序数组。时间复杂度：O(logn)，比线性查找高效得多。二、关键点前提条件有序性：数组必须有序（升序或降序），否则需先排序（但排序成本O(nlogn)）。静态性：适合静态数据或低频更新的数据（高频更新建议用哈希表或树结构）。两种边界问题左边界：第一个等于目标的位置（或第一
大整数加、减法（Java实现）与debug找错 gfu_ java 算法数据结构
前言这篇文章主要内容涉及大整数加法的实现以及debug使用的简单记录。以前当我碰到程序报错时，总是想找别人帮忙，感觉debug太难了，自己根本看不懂。这次，自己在做一道算法题时，程序能够运行，结果却出错了。本来想找别人帮忙，但想着学习还是要脚踏实地，于是自己硬着头皮上了，先在网上了解如何debug，然后一步一步找到了错误所在。主要是想记录下第一次debug找到问题的快乐。一、大整数加法（java）
Web3身份验证技术对数据保护的影响研究清晨反侦测指纹浏览器社交媒体 web3 ClonBrowser 跨境电商隐私保护
Web3身份验证技术对数据保护的影响研究在这个数字化时代，我们的身份和数据安全比以往任何时候都更加重要。Web3技术以其去中心化和用户主权的核心理念，为个人数据的管理和保护提供了新的视角。本文将探讨Web3身份验证技术如何影响数据保护，并分析其对我们数字生活的影响。Web3身份验证技术简介Web3身份验证技术依托于区块链和先进的加密技术，如非对称加密算法和智能合约，为用户提供了一种全新的身份验证方
金三银四快过去一半了，是时候加把劲了后端go找工作面试
从复旦春招会的15000+岗位争夺战，到AI算法岗年薪百万的“神仙打架”，再到游戏行业20:1的残酷竞争比，今年的金三银四像极了《三体》里的黑暗森林：机会看似遍地，但稍有不慎就成了别人的“背景板”。但现实真的是“投晚了就凉了”吗？数据告诉你真相：智联研究院统计显示，算法工程师、机器人算法工程师等岗位需求同比激增44%，而中小企业的“捡漏窗口”才刚开启。这半个月，我整理了20+场面试实录（含小鹅通、
动态规划算法优化在资源分配问题中的应用 suyang199312 课程设计
摘要资源分配问题广泛存在于各类生产与管理场景，合理分配资源以实现效益最大化至关重要。本文深入剖析动态规划算法在资源分配问题中的应用，详细阐述其基本原理与常规解法，针对常规解法的不足提出创新优化思路，并给出具体实现步骤。通过实际案例分析与实验验证，展示优化后的动态规划算法在提升资源分配效率和效益方面的显著优势，为相关领域的决策制定提供有力支持。引言在经济、工程、计算机科学等众多领域，资源分配问题无处
加密算法的性能优化与安全性平衡研究 sigen520520 笔记
摘要在数字化信息飞速发展的当下，数据安全至关重要，加密算法作为数据保护的核心手段，其性能与安全性直接关乎信息系统的稳定运行。本文深入剖析常见加密算法，详细分析其性能指标与安全性特点，全面探讨在提升加密速度的同时确保安全的有效方法与实践，旨在为构建高效、安全的加密体系提供理论支撑与实践指导。引言随着互联网的普及和信息技术的广泛应用，数据在传输与存储过程中面临诸多安全威胁，如数据泄露、篡改、伪造等。加
Matlab 基于最小二乘向量机 LSSVM + NSGAII 多目标优化算法的工艺参数优化前程算法屋私信获取源码工艺参数优化 matlab 算法多目标优化
Matlab基于最小二乘向量机LSSVM+NSGAII多目标优化算法的工艺参数优化一、引言1.1研究背景与意义在现代工业生产中，工艺参数优化占据着举足轻重的地位。它犹如工业生产的核心引擎，直接影响着企业的生产效率、产品质量以及成本控制。从生产效率角度看，优化工艺参数能够显著提升生产速度。合理的参数设置可使生产设备处于最佳运行状态，减少不必要的停机与等待时间，让生产流程更加顺畅。以汽车制造业为例，通
辗转相处求最大公约数沐刃青蛟 C++漏洞
无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！为此，总结一下以方便日后忘了好查找。 1.输入要比较的两个数a,b 忽略：2.比较大小（因为后面要的是大的数对小的数做%操作） 3.辗转相除（用循环不停的取余，如a%b,直至b=0） 4.最后的a为两数的最大公约数 &
F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5 负载均衡
一.什么是会话保持？在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
Object.equals方法：重载还是覆盖 Cwind java generics override overload
本文译自StackOverflow上对此问题的讨论。原问题链接在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
初始线程 15700786134
暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
Linux的tcpdump 被触发 tcpdump
用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。实用命令实例默认启动 tcpdump 普通情况下，直
安卓程序listview优化后还是卡顿肆无忌惮_ ListView
最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
扩展easyUI tab控件，添加加载遮罩效果知了ing jquery
(function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
gradle上传jar到nexus 矮蛋蛋 gradle
原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations { deployerJars } dependencies { deployerJars "org.apache.maven.wagon
千万条数据外网导入数据库的解决方案。 alleni123 sql mysql
从某网上爬了数千万的数据，存在文本中。然后要导入mysql数据库。悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作字符流
这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励我会更加的去学加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流字节流和字符的难点：a,怎么将读到的数据
MO、MT解读 bijian1013 GSM
MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息；上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
五个JavaScript基础问题 bijian1013 JavaScript call apply this Hoisting
下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。问题1：Scope作用范围考虑下面的代码： (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？回答：上面的代码会打印 5。 &nbs
【Thrift二】Thrift Hello World bit1129 Hello world
本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程 1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
【Avro一】Avro入门 bit1129 入门
本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。 1. 添加Maven依赖 <?xml version="1.0" encoding="UTF-8"?> <proj
安装nginx+ngx_lua支持WAF防护功能 ronin47
需要的软件:LuaJIT-2.0.0.tar.gz nginx-1.4.4.tar.gz &nb
java-5.查找最小的K个元素-使用最大堆 bylijinnan java
import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
TCP的TIME-WAIT bylijinnan socket
原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记说明：主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值 <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
Apache集群乱码和最高并发控制 cuisuqiang apache tomcat 并发集群乱码
都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
websocket dalan_123 websocket
一、低延迟的客户端-服务器和服务器-客户端的连接很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
菜鸟分析网络执法官 dcj3sjt126com 网络
最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包.
Android相对布局属性全集 dcj3sjt126com android
RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
Tomcat内存设置详解 eksliang jvm tomcat tomcat内存设置
Java内存溢出详解一、常见的Java内存溢出有以下三种： 1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。可以利用JVM提
Java6 JVM参数选项 greatwqs java HotSpot jvm jvm参数 JVM Options
Java 6 JVM参数选项大全（中文版）作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
weblogic创建JMC i5land weblogic jms
进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。系统包括几个独立的部分：使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子；使用 PHP CI 框架开发的简易网站；搜索引擎目前直接使用的 MySQL，将来可以考虑使
sql添加、删除表中的列 macroli sql
添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
PHP中二维数组的排序方法 abc123456789cba 排序二维数组 PHP
<?php/*** @package BugFree* @version $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hive hive优化
一、控制hive任务中的map数: 1. 通常情况下，作业会通过input的目录产生一个或者多个map任务。主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2.
Spring Boot 1.2.4 发布 wiselyman spring boot
Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。 Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多