（dfs序+莫队算法/启发式合并/树分治）Codeforces 375D

题意：

一颗根为1的树，每个节点有一个颜色，现在有十万次查询，问x的子树中数量超过k的颜色个数有几个。

分析：

一开始想了一下，朦朦胧胧的觉得dfs一下应该可以做，但是也只是朦朦胧胧，并不知道怎么下手。

百度了一下，“好题中的好题”，4解。

对于前两种方法，依赖于dfs序。

具体的可以自行百度，非常巧妙的东西。

至于莫队，首先莫队是个离线算法，用分块搞一下。

对所有查询排个序，然后不断移动两个指针维护信息即可，证明貌似是用曼哈顿距离生成树。有兴趣可以看看。

其实，整个过程很有滑动窗口的味道， 安排好所有查询的顺序，从左往右滑，不够就补信息，多了就删信息，虽然肯定会有浪费很多信息，不过根号复杂度也无所谓了。

后两种做法其实就是暴力的优化。

对于暴力，我们很自然的想法是每个节点存一个map，记录此子树的所有颜色个数，父亲的map由儿子的map合并而成。

至于维护答案，用一个可以查询Rank的平衡树即可，每次产生一个新的map值，就删掉存在Treap中旧的数量，然后添加新的。

对于启发式合并，上面讲的还不是关键，最关键的是“启发式”这三个字，即每次把小的map并到大的map中。

否则复杂度无法到达nlogn，又由于Treap的内容在跟随变化，整体复杂度为nlognlogn

最后一种方法，是最巧妙的，但正如上面说的，其实就是最暴力的优化。

我们将询问按x分类，对于每个节点进行暴力，那么最坏情况的复杂度显然是n^2。

然而其实，我们其实可以将子树的一部分信息保留到上一层父亲，最优秀的必然是将最大的子树保留给父亲。

所以利用dfs回溯的性质，对于每个节点，都会有1棵最大的子树不需要计算。

整体复杂度为nlogn，虽然我不会证明，不过凭感觉应该差不多。

代码：

dfs序+莫队算法：

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <vector>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-6)
#define fi first
#define se second
#define ls (n<<1)
#define rs (n<<1|1)
int sgn(double a) {
    return a < -eps ? -1 : a < eps ? 0 : 1;
}

//--------------------------

const int maxn = 100010;
const int mod = 1e9 + 7;


int n, q;
int col[maxn];
int L[maxn];
int R[maxn];
int d[maxn];
int tot = 0;
vector<int> g[maxn];
struct Q {
    int l, r, k, index;
} query[maxn];
int ans[maxn];
int suf[maxn];
int color[maxn];
int cs[maxn];
int bks;

bool cmp(Q a, Q b) {
    if (a.l / bks == b.l / bks)return a.r < b.r;
    else return a.l / bks < b.l / bks;
}

void dfs(int u, int fa, int dep) {
    L[u] = ++tot;
    color[tot] = col[u];
    d[u] = dep;
    for (int i = 0; i < g[u].size(); i++) {
        int v = g[u][i];
        if (v == fa)continue;
        dfs(v, u, dep + 1);
    }
    R[u] = tot;
}

void solve() {
    scanf("%d%d", &n, &q);
    bks = (int)sqrt(n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &col[i]);
    }
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    dfs(1, -1, 0);
    int v;
    for (int i = 0; i < q; i++) {
        scanf("%d%d", &v, &query[i].k);
        query[i].l = L[v];
        query[i].r = R[v];
        query[i].index = i;
    }
    sort(query, query + q, cmp);
    int pl = 1, pr = 0;
    for (int i = 0; i < q; i++) {
        int index = query[i].index;
        if (query[i].l == query[i].r) {
            ans[index] = query[i].k > 1 ? 0 : 1;
            continue;
        }
        if (pr < query[i].r) {
            for (int j = pr + 1; j <= query[i].r; j++) {
                suf[++cs[color[j]]]++;
            }

        } else {
            for (int j = pr; j > query[i].r; j--) {
                suf[cs[color[j]]--]--;
            }
        }
        pr = query[i].r;
        if (pl < query[i].l) {
            for (int j = pl; j < query[i].l; j++) {
                suf[cs[color[j]]--]--;
            }
        } else {
            for (int j = pl - 1; j >= query[i].l; j--) {
                suf[++cs[color[j]]]++;
            }
        }
        pl = query[i].l;
        ans[index] = suf[query[i].k];
    }
    for (int i = 0; i < q; i++) {
        printf("%d
", ans[i] );
    }
}


int main() {

#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    // freopen("1.out", "w", stdout);
#endif
    //iostream::sync_with_stdio(false);
    solve();
    return 0;
}

启发式合并：

#include <set>
#include <map>
#include <list>
#include <cmath>
#include <queue>
#include <vector>
#include <bitset>
#include <string>
#include <cctype>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <unordered_map>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define eps (1e-6)
#define fi first
#define se second
#define ls (n<<1)
#define rs (n<<1|1)
int sgn(double a) {
    return a < -eps ? -1 : a < eps ? 0 : 1;
}

//--------------------------

const int maxn = 100010;
const int mod = 1e9 + 7;


int n, q;
int col[maxn];
vector<int> g[maxn];
vector<pii> query[maxn];
unordered_map<int, int > color[maxn];
int ans[maxn];
struct Node {
    Node *son[2];
    int Key, w, Size;
    Node(int a, int b, int c, Node *d): Key(a), w(b), Size(c) {
        son[0] = son[1] = d;
    }
}*__root[maxn], *null;
void init() {
    null = new Node(-inf, inf, 0, 0); //这里维护的是小根堆
    for (int i = 1; i <= n; i++) {
        __root[i] = null = null->son[0] = null->son[1] = null;

    }
}
inline void Rotate(Node *&p, bool b) { //Rotate(p,0)表示;左旋Rotate(p,1)表示右旋
    Node *u = p->son[!b];
    p->son[!b] = u->son[b];
    u->son[b] = p;
    u->Size = p->Size;
    p->Size = p->son[0]->Size + p->son[1]->Size + 1;
    p = u;
}
void Insert(Node *&p, const int &x) { //注意引用
    if (p == null) { //如果找到了位置就插入
        p = new Node(x, rand(), 1, null);
        return;
    }
    bool b = (x > p->Key); //判断是往左子树还是右子树插入
    Insert(p->son[b], x);
    p->Size++;  //维护Size
    if (p->son[b]->w < p->w) Rotate(p, !b); //在左子树就右旋,在右子树就左旋
}
void Delete(Node *&p, const int &x) {
    if (p->son[0] == null && p->son[1] == null) {
        p = null; //这里是等到目标结点变为叶子才删除,仅比常规的删除多做了一次旋转,但代码短多了
        return;
    }
    bool b;  //这里的b为if语句后的操作提供了便利
    if (p->Key == x) {
        b = (p->son[1]->w > p->son[0]->w);
        Rotate(p, b);
    }  else b = (x > p->Key);
    p->Size--;
    Delete(p->son[b], x);
}
int Rank(int x, int index) { //返回x的排名(第几小)
    Node *p = __root[index];
    int Count = 0;
    for (; p != null; )
        if (p->Key < x) {
            Count += p->son[0]->Size + 1;
            p = p->son[1];
        }  else p = p->son[0];
    return Count + 1;
}

bool Find(int x, int index) {
    Node *p = __root[index];
    for (; p != null;) {
        if (p->Key < x)p = p->son[1];
        else if (p->Key > x)p = p->son[0];
        else return true;
    }
    return false;
}

void dfs(int u, int fa) {
    if (Find(color[u][col[u]], u))Delete(__root[u], color[u][col[u]]);
    color[u][col[u]]++;
    Insert(__root[u], color[u][col[u]]);
    for (int i = 0; i < g[u].size(); i++) {
        int v = g[u][i];
        if (v == fa)continue;
        dfs(v, u);
        if (color[u].size() < color[v].size()) {
            swap(color[u], color[v]);
            swap(__root[u], __root[v]);
        }
        for (unordered_map<int, int >::iterator it = color[v].begin(); it != color[v].end(); it++) {
            if (Find(color[u][it->fi], u))Delete(__root[u], color[u][it->fi]);
            color[u][it->fi] += it->se;
            Insert(__root[u], color[u][it->fi]);
        }
    }
    for (int i = 0; i < query[u].size(); i++) {
        ans[query[u][i].se] = __root[u]->Size - Rank(query[u][i].fi, u) + 1;
    }

}

void solve() {
    scanf("%d%d", &n, &q);
    init();
    for (int i = 1; i <= n; i++) {
        scanf("%d", &col[i]);
    }
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for (int i = 0; i < q; i++) {
        int v, k;
        scanf("%d%d", &v, &k);
        query[v].push_back(make_pair(k, i));
    }
    dfs(1, -1);
    for (int i = 0; i < q; i++) {
        printf("%d
", ans[i] );
    }


}


int main() {

#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    // freopen("1.out", "w", stdout);
#endif
    //iostream::sync_with_stdio(false);
    solve();
    return 0;
}

分治：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<set>
#include<vector>
#include<queue>
#include<map>
#include<list>
#include<bitset>
#include<string>
#include<cctype>
#include<cstdlib>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
#define inf (0x3f3f3f3f)
#define lnf (0x3f3f3f3f3f3f3f3f)
#define fi first
#define se second
#define eps (1e-8)
int sgn(double a) {
    return a < -eps ? -1 : a < eps ? 0 : 1;
}

const int maxn = 100010;

int n, q;
int col[maxn];
vector<int> g[maxn];
vector<pii> query[maxn];
int sz[maxn];
int cnt[maxn];
int sum[maxn];
int ans[maxn];
bool big[maxn];
int tot = 0;

void dfs1(int u, int fa) {
    sz[u] = 1;
    for (int i = 0; i < g[u].size(); i++) {
        int v = g[u][i];
        if (v == fa)continue;
        dfs1(v, u);
        sz[u] += sz[v];
    }
}

void add(int v, int p, int x) {
    if(x == 1) {
        sum[++cnt[col[v]]]++;
    } else {
        sum[cnt[col[v]]--]--;
    }
    for(auto u : g[v])
        if(u != p && !big[u]) {
            add(u, v, x);
        }
}

void dfs(int v, int p, bool keep) {
    int mx = -1, bigChild = -1;
    for(auto u : g[v])
        if(u != p && sz[u] > mx)
            mx = sz[u], bigChild = u;
    for(auto u : g[v])
        if(u != p && u != bigChild)
            dfs(u, v, 0); 
    if(bigChild != -1)
        dfs(bigChild, v, 1), big[bigChild] = 1; 
    add(v, p, 1);
    for (int i = 0; i < query[v].size(); i++) {
        ans[query[v][i].se] = sum[query[v][i].fi];
    }
    if(bigChild != -1)
        big[bigChild] = 0;
    if(keep == 0)
        add(v, p, -1);
}

void solve() {
    scanf("%d%d", &n, &q);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &col[i]);
    }
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        g[u].push_back(v);
        g[v].push_back(u);
    }
    for (int i = 0; i < q; i++) {
        int v, k;
        scanf("%d%d", &v, &k);
        query[v].push_back(make_pair(k, i));
    }
    dfs1(1, -1);
    dfs(1, -1, false);
    for (int i = 0; i < q; i++) {
        printf("%d
", ans[i] );
    }


}

int main() {

#ifndef ONLINE_JUDGE
    freopen("1.in", "r", stdin);
    //freopen("1.out", "w", stdout);
#endif
    //iostream::sync_with_stdio(false);
    solve();
    return 0;
}