Tree Queries（ Codeforces Round 629 (Div. 3) ）-CSDN博客

本文链接：https://blog.csdn.net/2301_80379979/article/details/145382723

Tree Queries（ Codeforces Round 629 (Div. 3) ）

You are given a rooted tree consisting of $n$ vertices numbered from $1$ to $n$ . The root of the tree is a vertex number $1$ .

A tree is a connected undirected graph with $n - 1$ edges.

You are given $m$ queries. The $i$ -th query consists of the set of $k_i$ distinct vertices $v_i[1], v_i[2], \dots, v_i[k_i]$ . Your task is to say if there is a path from the root to some vertex $u$ such that each of the given $k$ vertices is either belongs to this path or has the distance $1$ to some vertex of this path.

Input

The first line of the input contains two integers $n$ and $m$ ( $\le n \le 2 \cdot 10^5$ , $\le m \le 2 \cdot 10^5$ ) — the number of vertices in the tree and the number of queries.

Each of the next $n - 1$ lines describes an edge of the tree. Edge $i$ is denoted by two integers $u_i$ and $v_i$ , the labels of vertices it connects $\le u_i, v_i \le n, u_i \ne v_i$ ).

It is guaranteed that the given edges form a tree.

The next $m$ lines describe queries. The $i$ -th line describes the $i$ -th query and starts with the integer $k_i$ ( $\le k_i \le n$ ) — the number of vertices in the current query. Then $k_i$ integers follow: $v_i[1], v_i[2], \dots, v_i[k_i]$ ( $\le v_i[j] \le n$ ), where $v_i[j]$ is the $j$ -th vertex of the $i$ -th query.

It is guaranteed that all vertices in a single query are distinct.

It is guaranteed that the sum of $k_i$ does not exceed $\cdot 10^5$ ( $\sum\limits_{i=1}^{m} k_i \le 2 \cdot 10^5$ ).

Output

For each query, print the answer — “YES”, if there is a path from the root to some vertex $u$ such that each of the given $k$ vertices is either belongs to this path or has the distance $1$ to some vertex of this path and “NO” otherwise.

Example

Input

Copy

Output

Copy

YES
YES
YES
YES
NO
NO

Note

The picture corresponding to the example:

Consider the queries.

The first query is $[3, 8, 9, 10]$ . The answer is “YES” as you can choose the path from the root $1$ to the vertex $u = 10$ . Then vertices $[3, 9, 10]$ belong to the path from $1$ to $10$ and the vertex $8$ has distance $1$ to the vertex $7$ which also belongs to this path.

The second query is $[2, 4, 6]$ . The answer is “YES” as you can choose the path to the vertex $u = 2$ . Then the vertex $4$ has distance $1$ to the vertex $1$ which belongs to this path and the vertex $6$ has distance $1$ to the vertex $2$ which belongs to this path.

The third query is $[2, 1, 5]$ . The answer is “YES” as you can choose the path to the vertex $u = 5$ and all vertices of the query belong to this path.

The fourth query is $[4, 8, 2]$ . The answer is “YES” as you can choose the path to the vertex $u = 9$ so vertices $2$ and $4$ both have distance $1$ to the vertex $1$ which belongs to this path and the vertex $8$ has distance $1$ to the vertex $7$ which belongs to this path.

The fifth and the sixth queries both have answer “NO” because you cannot choose suitable vertex $u$ .

题目大意

本题给定一棵有根树，树中包含 $n$ 个从 $1$ 到 $n$ 编号的顶点，根节点为顶点 $1$ 。同时还会给出 $m$ 个查询，每个查询包含一组不同的顶点。对于每个查询，需要判断是否存在一条从根节点到某个顶点 $u$ 的路径，使得查询中的每个顶点要么属于这条路径，要么与路径上的某个顶点距离为 $1$ 。

输入格式

第一行包含两个整数 $n$ 和 $m$ ，分别表示树的顶点数和查询数。
接下来的 $n - 1$ 行，每行描述一条树的边，包含两个整数 $u_i$ 和 $v_i$ ，表示连接的两个顶点。
- 再接下来的 $m$ 行，每行描述一个查询。每行首先是一个整数 $k_i$ ，表示该查询中的顶点数，随后跟着 $k_i$ 个不同的整数，表示查询中的顶点。

输出格式

对于每个查询，如果存在满足条件的路径，输出 “YES”，否则输出 “NO”。

解题思路

选择最深顶点：在每个查询中，选择一个距离根节点最远的顶点 $f v$ 。因为若存在满足条件的路径，它大概率会延伸到这个最深顶点。
顶点替换：将查询中除根节点和 $f v$ 之外的每个顶点替换为其父节点。这样做是为了将距离路径为 $1$ 的顶点转化为路径上的顶点来处理。
路径判断：检查替换后的每个顶点是否都在从根节点到 $f v$ 的路径上。为了实现这一判断，使用深度优先搜索（DFS）预处理每个顶点的进入时间 tin 和离开时间 tout。利用这两个时间信息，通过判断区间包含关系来确定一个顶点是否是另一个顶点的父节点，进而判断一个顶点是否在从根节点到 $f v$ 的路径上。 ### 代码分析

代码整体结构

代码主要由以下几个部分组成：

头文件和常量定义：包含了常用的头文件，定义了一些常量，如 MAXN 和 LOG，用于确定最大节点数和倍增算法所需的对数。
全局变量：定义了节点数 $n$ 、查询数 $m$ 、树的邻接表 tree、倍增数组 up 和深度数组 depth。
- DFS 函数：用于预处理每个节点的父节点信息和深度信息，同时进行倍增数组的初始化。
- - LCA 函数：使用倍增算法查找两个节点的最近公共祖先（LCA）。
  - - solved 函数：处理输入，调用 dfs 函数进行预处理，然后处理每个查询。
    - - 主函数：初始化输入输出流，调用 solved 函数解决问题。
        
        详细代码分析

#include <map>
#include <set>
#include <fstream>
#include <queue>
#include <deque>
#include <stack>
#include <vector>
#include <string>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <bitset>
#include <iomanip>
#define endl '\n'
#define int long long
#define Max(a, b) (((a) > (b)) ? (a) : (b))
#define Min(a, b) (((a) < (b)) ? (a) : (b))
#define BoBoowen ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
using namespace std;

const int inf = 1e9 + 7;
const int N = 5e5 + 10;

const int MAXN = 500005; // 假设节点数最多为 500005
const int LOG = 30;      // 2^30 > 500005，足够用于预处理

int n, m; // n 为节点数，m 为查询数
int q;
vector<int> tree[MAXN];
int up[MAXN][LOG], depth[MAXN];

// 深度优先搜索预处理父节点和深度信息
void dfs(int u, int parent, int dep)
{
    up[u][0] = parent;
    depth[u] = dep;
    for (int i = 1; i < LOG; i++)
    {
        if (up[u][i - 1] != -1)
        {
            up[u][i] = up[up[u][i - 1]][i - 1];
        }
        else
        {
            break;
        }
    }
    for (int v : tree[u])
    {
        if (v != parent)
        {
            dfs(v, u, dep + 1);
        }
    }
}

// 查找 u 和 v 的 LCA
int lca(int u, int v)
{
    // 如果 u 比 v 深，交换 u 和 v
    if (depth[u] < depth[v])
        swap(u, v);

    // 将 u 提升到和 v 同样的深度
    for (int i = LOG - 1; i >= 0; i--)
    {
        if (depth[u] - (1 << i) >= depth[v])
        {
            u = up[u][i];
        }
    }

    // 如果 u 和 v 相同，返回 u
    if (u == v)
        return u;

    // 向上跳跃直到找到 LCA
    for (int i = LOG - 1; i >= 0; i--)
    {
        if (up[u][i] != up[v][i])
        {
            u = up[u][i];
            v = up[v][i];
        }
    }

    // 最终 u 和 v 的父节点即为 LCA
    return up[u][0];
}

int cmp(pair<int, int> p1, pair<int, int> p2)
{
    return p1.first < p2.first;
}

void solved()
{
    // 输入处理
    cin >> n >> q;
    m = n - 1;
    for (int i = 1; i < n; i++)
    {
        int u, v;
        cin >> u >> v;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    // 初始化倍增信息
    memset(up, -1, sizeof(up));
    dfs(1, -1, 0); // 假设 1 为根节点

    // 处理查询
    while (q--)
    {
        int k;
        cin >> k;
        vector<int> v(k);
        int depp = 1;
        for (int i = 0; i < k; ++i)
        {
            cin >> v[i];
            if (v[i] != 1)
            {
                v[i] = up[v[i]][0];
            }
            if (depth[depp] < depth[v[i]])
            {
                depp = v[i];
            }
        }
        int flag = 1;
        for (int i = 0; i < k; ++i)
        {
            if (lca(v[i], depp) != v[i])
            {
                flag = 0;
                break;
            }
        }

        if (flag)
        {
            cout << "YES" << endl;
        }
        else
        {
            cout << "NO" << endl;
        }
    }
}

signed main()
{
    BoBoowen;

    int T = 1;
    // cin >> T;
    while (T--)
    {
        solved();
    }
}

各部分代码解释

dfs 函数 - 接收当前节点 u、父节点 parent 和深度 dep 作为参数。

初始化 up[u][0] 为父节点，depth[u] 为当前深度。
- 通过倍增算法预处理 up 数组，用于快速查找祖先节点。
- 递归调用 dfs 函数处理子节点。

2.lca 函数 - 首先比较两个节点的深度，将较深的节点提升到与较浅节点相同的深度。 - 然后通过倍增算法向上跳跃，直到找到两个节点的最近公共祖先。

solved 函数 - 读取输入的节点数 $n$ 和查询数 $q$ ，构建树的邻接表。 - 调用 dfs 函数进行预处理。 - 对于每个查询，读取查询中的顶点数 $k$ 和顶点列表。 - 将非根节点替换为其父节点，并找到最深的顶点 depp。 - 检查每个顶点是否在从根节点到 depp 的路径上，通过判断 lca(v[i], depp) 是否等于 v[i] 来实现。 - 根据检查结果输出 “YES” 或 “NO”。
主函数 - 初始化输入输出流，调用 solved 函数解决问题。