对于Q查询，在给定的最小频率下，彩色树的子树中不同颜色的计数

给定一棵具有与每个节点和Q查询相关联的颜色的N元树。每个查询包含两个整数A和X。任务是对以A为根的子树中的所有不同颜色进行计数，该子树中的颜色频率大于或等于该子树中的X。

例子：

Input: Tree:

query[] = {{1, 2}, {1, 3}, {1, 4}, {2, 3}, {5, 3}}
Output: {2, 2, 1, 0, 1}
Explanation:
In the subtree rooted at 1, the frequency of colour 2 is 3 and colour 3 is 4. So the answer is 2 for the 1 query, 2 for 2nd query and 1 for 3rd query.
For subtree rooted at 2, frequency of color 2 is 2 and color 3 is 1. So no color have frequency more than or equal to 4.
For subtree rooted at 5, frequency of color 2 is 1 and color 3 is 3. So color 3 have frequency equal to 3.

天真的方法

• 对于每个查询，我们将遍历给定节点的整个子树。
• 我们将维护一个映射，该映射将每种颜色的频率存储在给定节点的子树中。
• 然后，遍历贴图并计算颜色数，以使其频率大于给定的x。

时间复杂度： O(Q * N)
空间复杂度： O(Q * N)

方法：(使用莫氏算法)

• 我们将首先使用Euler Tour将树弄平。
• 我们将把数字分配给每个节点，何时将其放入DFS中以及何时该节点出来。让我们用tin [node]和tout [node]表示每个节点。
• 将树展平为数组后，的每个子树都可以表示为某个数组，其开始和结束索引分别为tin [node]和tout [node] 。
• 现在，问题变成了某些子阵列中频率大于X的元素数量。
• 我们将使用Mo的算法来解决此问题。
• 首先，我们将存储查询并根据tin [node] / SQ对其进行排序，其中SQ是N的平方根。
• 当我们移动指针时，我们将在第i个颜色处将频率存储在数组中，并将查询的答案存储在数组的第X个位置，因为它存储的频率大于X的颜色计数。

1(1)
         /       \ 
       /          \
     2(2)         5(3)
    /   \       /  |   \
   /     \     /   |    \
3(2)    4(3) 6(2) 7(3)  8(3)

输出：

// C++ program to count distinct colors
// in a subtree of a Colored Tree
// with given min frequency for Q queries
  
#include 
using namespace std;
  
const int N = 1e5 + 5;
  
// graph as adjacency list
vector > v(N);
  
// colour written on node.
vector colour(N);
  
// order of node entering in DFS
vector in(N);
  
// order of node exiting in DFS
vector out(N);
  
// for counting the frequency of
// nodes with colour i
vector cnt(N);
  
// for storing frequency of colours
vector freq(N);
  
// tree in a flatten
// form (using Euler tour)
vector flatTree(N);
  
// number of nodes
int n,
  
    // square root of n
    sq;
  
// indexes for in and
// out of node in DFS
int start = 0;
  
// DFS function to find
// order of euler tour
void DFSEuler(int a, int par)
{
  
    // stroing the start index
    in[a] = ++start;
  
    // storing colour of node
    // in flatten array
    flatTree[start] = colour[a];
  
    for (int i : v[a]) {
  
        // doing DFS on its child
        // skipping parent
        if (i == par)
            continue;
  
        DFSEuler(i, a);
    }
  
    // out index of the node.
    out[a] = start;
}
  
// comparator for queries
bool comparator(pair& a,
                pair& b)
{
    // comparator for queries to be
    // sorted accoring to in[x] / sq
    if (in[a.first] / sq != in[b.first] / sq)
        return in[a.first] < in[b.first];
  
    return out[a.first] < out[b.first];
}
  
// Function to answer the queries
void solve(vector > arr,
           int q)
{
    sq = sqrt(n) + 1;
  
    // for storing answers
    vector answer(q);
  
    // for storing indexes of queries
    // in the order of input.
    map, int> idx;
  
    for (int i = 0; i < q; i++) {
  
        // storing indexes of queries
        idx[arr[i]] = i;
    }
  
    // doing depth first search to
    // find indexes to flat the
    // tree using euler tour.
    DFSEuler(1, 0);
  
    // After doing Euler tour,
    // subtree of x can be
    // represented as a subarray
    // from in[x] to out[x];
  
    // we'll sort the queries
    // according to the in[i];
    sort(arr.begin(),
         arr.end(),
         comparator);
  
    // two pointers for
    // sliding the window
    int l = 1, r = 0;
  
    for (int i = 0; i < q; i++) {
  
        // finding answer to the query
        int node = arr[i].first,
            x = arr[i].second;
        int id = idx[arr[i]];
  
        while (l > in[node]) {
  
            // decrementing the pointer as
            // it is greater than start
            // and adding answer
            // to our freq array.
            l--;
            cnt[flatTree[l]]++;
            freq[cnt[flatTree[l]]]++;
        }
  
        while (r < out[node]) {
  
            // incrementing pointer as it is
            // less than the end value and
            // adding answer to our freq array.
            r++;
            cnt[flatTree[r]]++;
            freq[cnt[flatTree[r]]]++;
        }
  
        while (l < in[node]) {
  
            // removing the lth node from
            // freq array and incrementing
            // the pointer
            freq[cnt[flatTree[l]]]--;
            cnt[flatTree[l]]--;
            l++;
        }
  
        while (r > out[node]) {
  
            // removing the rth node from
            // freq array and decrementing
            // the pointer
            freq[cnt[flatTree[r]]]--;
            cnt[flatTree[r]]--;
            r--;
        }
  
        // answer to this query
        // is stored at freq[x]
        // freq[x] stores the frequency
        // of nodes greater equal to x
        answer[id] = freq[x];
    }
  
    // printing the queries
    for (int i = 0; i < q; i++)
        cout << answer[i] << " ";
}
  
int main()
{
    // Driver Code
    /*
               1(1)
             /       \ 
           /          \
         2(2)         5(3)
        /   \       /  |   \
       /     \     /   |    \
    3(2)    4(3) 6(2) 7(3)  8(3)
    */
    n = 8;
    v[1].push_back(2);
    v[2].push_back(1);
    v[2].push_back(3);
    v[3].push_back(2);
    v[2].push_back(4);
    v[4].push_back(2);
    v[1].push_back(5);
    v[5].push_back(1);
    v[5].push_back(6);
    v[6].push_back(5);
    v[5].push_back(7);
    v[7].push_back(5);
    v[5].push_back(8);
    v[8].push_back(5);
  
    colour[1] = 1;
    colour[2] = 2;
    colour[3] = 2;
    colour[4] = 3;
    colour[5] = 3;
    colour[6] = 2;
    colour[7] = 3;
    colour[8] = 3;
  
    vector > queries
        = { { 1, 2 },
            { 1, 3 },
            { 1, 4 },
            { 2, 3 },
            { 5, 3 } };
    int q = queries.size();
  
    solve(queries, q);
    return 0;
}

时间复杂度： $O(Q * \sqrt{N})$
空间复杂度： $O(N)$

如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。