Codeforces Round 888 (Div. 3)

InHng

已于 2023-09-16 17:56:56 修改

阅读量167

点赞数

文章标签：算法 c++ python

于 2023-08-26 07:19:34 首次发布

本文链接：https://blog.csdn.net/m0_70675786/article/details/132498356

版权

A. Escalator Conversations

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input outputL: standard output

One day, Vlad became curious about who he can have a conversation with on the escalator in the subway. There are a total of $n$ passengers. The escalator has a total of $m$ steps, all steps indexed from $1$ to $m$ and $i$ -th step has height $\cdot k$ .

Vlad’s height is $H$ centimeters. Two people with heights $a$ and $b$ can have a conversation on the escalator if they are standing on different steps and the height difference between them is equal to the height difference between the steps.

For example, if two people have heights $170$ and $180$ centimeters, and $m = 10, k = 5$ , then they can stand on steps numbered $7$ and $5$ , where the height difference between the steps is equal to the height difference between the two people: $\cdot 2 = 5 \cdot 2 = 10 = 180 - 170$ . There are other possible ways.

Given an array $h$ of size $n$ , where $h_i$ represents the height of the $i$ -th person. Vlad is interested in how many people he can have a conversation with on the escalator individually.

For example, if $n = 5, m = 3, k = 3, H = 11$ , and $h = [5, 4, 14, 18, 2]$ , Vlad can have a conversation with the person with height $5$ (Vlad will stand on step $1$ , and the other person will stand on step $3$ ) and with the person with height $14$ (for example, Vlad can stand on step $3$ , and the other person will stand on step $2$ ). Vlad cannot have a conversation with the person with height $2$ because even if they stand on the extreme steps of the escalator, the height difference between them will be $6$ , while their height difference is $9$ . Vlad cannot have a conversation with the rest of the people on the escalator, so the answer for this example is $2$ .

Input

The first line contains a single integer $t$ ( $\le t \le 1000$ ) — the number of test cases.

Then the descriptions of the test cases follow.

The first line of each test case contains integers: $n, m, k, H$ ( $\le n,m \le 50$ , $\le k,H \le 10^6$ ). Here, $n$ is the number of people, $m$ is the number of steps, $k$ is the height difference between neighboring steps, and $H$ is Vlad’s height.

The second line contains $n$ integers: $h_1, h_2, \ldots, h_n$ ( $\le h_i \le 10^6$ ). Here, $h_i$ represents the height of the $i$ -th person.

Output

For each test case, output a single integer — the number of people Vlad can have a conversation with on the escalator individually.

Example
input

7
5 3 3 11
5 4 14 18 2
2 9 5 6
11 9
10 50 3 11
43 44 74 98 62 60 99 4 11 73
4 8 8 49
68 58 82 73
7 1 4 66
18 66 39 83 48 99 79
9 1 1 13
26 23 84 6 60 87 40 41 25
6 13 3 28
30 70 85 13 1 55

output

Note

The first example is explained in the problem statement.

In the second example, Vlad can have a conversation with the person with height $11$ .

In the third example, Vlad can have a conversation with people with heights: $44, 74, 98, 62$ . Therefore, the answer is $4$ .

In the fourth example, Vlad can have a conversation with the person with height $73$ .

Tutorial
两个人站的位置不能在同一级，同时他们之间的差值应该能被 k 整除，同时他们差的楼梯数不能超过 m

Solution

for _ in range(int(input())):
    cnt = 0
    n, m, k, H = map(int, input().split())
    a = list(map(int, input().split()))
    for i, h in enumerate(a):
        if abs(H - h) % k == 0 and abs(H - h) / k < m and abs(H - h) / k > 0:
            cnt += 1
    print(cnt)

B. Parity Sort

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input outputL: standard output

You have an array of integers $a$ of length $n$ . You can apply the following operation to the given array:

Swap two elements $a_i$ and $a_j$ such that $\neq j$ , $a_i$ and $a_j$ are either both even or both odd.

Determine whether it is possible to sort the array in non-decreasing order by performing the operation any number of times (possibly zero).

For example, let $a$ = [ $7, 10, 1, 3, 2$ ]. Then we can perform $3$ operations to sort the array:

Swap $a_3 = 1$ and $a_1 = 7$ , since $1$ and $7$ are odd. We get $a$ = [ $1, 10, 7, 3, 2$ ];
Swap $a_2 = 10$ and $a_5 = 2$ , since $10$ and $2$ are even. We get $a$ = [ $1, 2, 7, 3, 10$ ];
Swap $a_4 = 3$ and $a_3 = 7$ , since $3$ and $7$ are odd. We get $a$ = [ $1, 2, 3, 7, 10$ ].

Input

The first line of input data contains a single integer $t$ ( $\le t \le 10^4$ ) — the number of test cases.

The description of the test cases follows.

The first line of each test case contains one integer $n$ ( $\le n \le 2 \cdot 10^5$ ) — the length of array $a$ .

The second line of each test case contains exactly $n$ positive integers $a_1, a_2, \dots, a_n$ ( $\le a_i \le 10^9$ ) — the elements of array $a$ .

It is guaranteed that the sum of $n$ over all test cases does not exceed $\cdot 10^5$ .

Output

For each test case, output on a separate line:

YES if the array can be sorted by applying the operation to it some number of times;
NO otherwise.

You can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as positive response).

Example
input

6
5
7 10 1 3 2
4
11 9 3 5
5
11 3 15 3 2
6
10 7 8 1 2 3
1
10
5
6 6 4 1 6

output

YES
YES
NO
NO
YES
NO

Note

The first test case is explained in the problem statement.

Tutorial
将原有的数组复制到另一个数组，然后对其进行排序，最后看相应位置上的数字奇偶性是否统一，如果不统一就是 NO，否则为 YES

Solution

for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    b = sorted(a)
    flag = True
    for i, x in enumerate(b):
        if x & 1 != a[i] & 1:
            flag = False
            break
    if flag:
        print("YES")
    else:
        print("NO")

C. Tiles Comeback

time limit per test: 2 second memory limit per test: 256 megabytes input: standard input outputL: standard output

Vlad remembered that he had a series of $n$ tiles and a number $k$ . The tiles were numbered from left to right, and the $i$ -th tile had colour $c_i$ .

If you stand on the first tile and start jumping any number of tiles right, you can get a path of length $p$ . The length of the path is the number of tiles you stood on.

Vlad wants to see if it is possible to get a path of length $p$ such that:

it ends at tile with index $n$ ;
$p$ is divisible by $k$
the path is divided into blocks of length exactly $k$ each;
tiles in each block have the same colour, the colors in adjacent blocks are not necessarily different.

For example, let $n = 14$ , $k = 3$ .

The colours of the tiles are contained in the array $c$ = [ $\color{red}{1}, \color{violet}{2}, \color{red}{1}, \color{red}{1}, \color{gray}{7}, \color{orange}{5}, \color{green}{3}, \color{green}{3}, \color{red}{1}, \color{green}{3}, \color{blue}{4}, \color{blue}{4}, \color{violet}{2}, \color{blue}{4}$ ]. Then we can construct a path of length $6$ consisting of $2$ blocks:

$\color{red}{c_1} \rightarrow \color{red}{c_3} \rightarrow \color{red}{c_4} \rightarrow \color{blue}{c_{11}} \rightarrow \color{blue}{c_{12}} \rightarrow \color{blue}{c_{14}}$

All tiles from the $1$ -st block will have colour $\color{red}{\textbf{1}}$ , from the $2$ -nd block will have colour $\color{blue}{\textbf{4}}$ .

It is also possible to construct a path of length $9$ in this example, in which all tiles from the $1$ -st block will have colour $\color{red}{\textbf{1}}$ , from the $2$ -nd block will have colour $\color{green}{\textbf{3}}$ , and from the $3$ -rd block will have colour $\color{blue}{\textbf{4}}$ .

Input

The first line of input data contains a single integer $t$ ( $\le t \le 10^4$ ) — the number of test cases.

The description of the test cases follows.

The first line of each test case contains two integers $n$ and $k$ ( $\le k \le n \le 2 \cdot 10^5$ )—the number of tiles in the series and the length of the block.

The second line of each test case contains $n$ integers $c_1, c_2, c_3, \dots, c_n$ ( $\le c_i \le n$ ) — the colours of the tiles.

It is guaranteed that the sum of $n$ over all test cases does not exceed $\cdot 10^5$ .

Output

For each test case, output on a separate line:

YES if you can get a path that satisfies these conditions;
NO otherwise.

You can output YES and NO in any case (for example, strings yEs, yes, Yes and YES will be recognized as positive response).

Example
input

10
4 2
1 1 1 1
14 3
1 2 1 1 7 5 3 3 1 3 4 4 2 4
3 3
3 1 3
10 4
1 2 1 2 1 2 1 2 1 2
6 2
1 3 4 1 6 6
2 2
1 1
4 2
2 1 1 1
2 1
1 2
3 2
2 2 2
4 1
1 1 2 2

output

YES
YES
NO
NO
YES
YES
NO
YES
YES
YES

Note

In the first test case, you can jump from the first tile to the last tile;

The second test case is explained in the problem statement.

Tutorial
路径必须是以第一个图块开始，最后一个图块结束，所以只需要考虑如下两种情况：

如果 $c_1 = c_n$ ，则此时只需要考虑能否构成 $1$ 个长度为 $k$ 的连通块，即只需要判断第一个图块和最后一个图块之间是否有 $k - 2$ 个颜色为 $c_0$ 的图块
如果 $c_1 \neq c_n$ ，可以使用双指针，从 $c_1$ 移动到 $c_n$ ，看两者能否在不晚于 $k$ 个块相遇，如果没有相遇则答案为 $Y ES$ ，否则为 $NO$

Solution

for _ in range(int(input())):
    n, k = map(int, input().split())
    c = list(map(int, input().split()))
    a, b, x, y, cnt = c[0], c[-1], -1, -1, 0
    for i, ci in enumerate(c):
        cnt += ci == a
        if cnt == k:
            x = i
            break
    cnt = 0
    for i, ci in enumerate(c[::-1]):
        cnt += ci == b
        if cnt == k:
            y = n - i - 1
            break
    if a == b and x != -1:
        print("YES")
    elif x == -1 or y == -1 or x > y:
        print("NO")
    else:
        print("YES")

D. Prefix Permutation Sums

time limit per test: 3 second memory limit per test: 256 megabytes input: standard input outputL: standard output

Your friends have an array of $n$ elements, calculated its array of prefix sums and passed it to you, accidentally losing one element during the transfer. Your task is to find out if the given array can matches permutation.

A permutation of $n$ elements is an array of $n$ numbers from $1$ to $n$ such that each number occurs exactly one times in it.

The array of prefix sums of the array $a$ — is such an array $b$ that $b_i = \sum_{j=1}^i a_j, 1 \le i \le n$ .

For example, the original permutation was $[1, 5, 2, 4, 3]$ . Its array of prefix sums — $[1, 6, 8, 12, 15]$ . Having lost one element, you can get, for example, arrays $[6, 8, 12, 15]$ or $[1, 6, 8, 15]$ .

It can also be shown that the array $[1, 2, 100]$ does not correspond to any permutation.

Input

The first line contains a positive number $t$ ( $\le t \le 10^4$ ) — the number of test cases. The description of the test cases follows.

The first line of the description of each test case contains a positive number $n$ ( $\le n \le 2 \cdot 10^5$ ) — the size of the initial array.

The second line of the description of each test case contains $n - 1$ positive number $a_i$ ( $\le a_i \le 10^{18}$ ), $a_{i-1} < a_i$ — elements of the array of prefix sums.

It is guaranteed that the sum of $n$ over all test cases does not exceed $\cdot 10^5$ .

Output

For each test case, output “YES” if such a permutation exists, and “NO” otherwise.

You can output “YES” and “NO” in any case (for example, the strings “yEs”, “yes” and “Yes” will be recognized as a positive response).

Example
input

12
5
6 8 12 15
5
1 6 8 15
4
1 2 100
4
1 3 6
2
2
3
1 2
4
3 7 10
5
5 44 46 50
4
1 9 10
5
13 21 36 42
5
1 2 3 1000000000000000000
9
9 11 12 20 25 28 30 33

output

YES
YES
NO
YES
YES
NO
YES
NO
NO
NO
NO
NO

Note

In the fourth example, for example, the permutation $[1, 2, 3, 4]$ is suitable. In the fifth example, for example, the permutation $[2, 1]$ is suitable. In the seventh example, for example, the permutation $[1, 2, 4, 3]$ is suitable.

Tutorial
先用题目给出的数组判断有哪些数缺失，如果只缺失了一个元素，那么直接可以判断为 YES，如果缺失了三个元素或者更多，则可以直接判断为 NO，如果恰好缺失了两个元素，再判断他是否缺少了两边的元素

Solution

from collections import Counter

for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    mp = Counter()
    judge = []
    for i, x in enumerate(a):
        if i:
            mp[x - a[i - 1]] += 1
        else:
            mp[x] += 1
    for i in range(1, n + 1):
        if mp[i] == 0:
            judge.append(i)
    if len(judge) == 1:
        print("YES")
    elif len(judge) > 2:
        print("NO")
    else:
        print("YES" if mp[judge[0] + judge[1]] > (sum(judge) <= n) else "NO")

E. Nastya and Potions

time limit per test: 3 second memory limit per test: 256 megabytes input: standard input outputL: standard output

Alchemist Nastya loves mixing potions. There are a total of $n$ types of potions, and one potion of type $i$ can be bought for $c_i$ coins.

Any kind of potions can be obtained in no more than one way, by mixing from several others. The potions used in the mixing process will be consumed. Moreover, no potion can be obtained from itself through one or more mixing processes.

As an experienced alchemist, Nastya has an unlimited supply of $k$ types of potions $p_1, p_2, \dots, p_k$ , but she doesn’t know which one she wants to obtain next. To decide, she asks you to find, for each $\le i \le n$ , the minimum number of coins she needs to spend to obtain a potion of type $i$ next.

Input

The first line of each test contains an integer $t$ ( $\le t \le 10^4$ ) — the number of test cases.

Each test case is described as follows:

The first line contains two integers $n$ and $k$ ( $\le k < n \le 2 \cdot 10^5$ ) — the total number of potion types and the number of potion types Nastya already has.

The second line contains $n$ integers $c_1, c_2, \dots, c_n$ ( $\le c_i \le 10^9$ ) — the costs of buying the potions.

The third line contains $k$ distinct integers $p_1, p_2, \dots, p_k$ ( $\le p_i \le n$ ) — the indices of potions Nastya already has an unlimited supply of.

This is followed by $n$ lines describing ways to obtain potions by mixing.

Each line starts with the integer $m_i$ ( $\le m_i < n$ ) — the number of potions required to mix a potion of the type $i$ ( $\le i \le n$ ).

Then line contains $m_i$ distinct integers $e_1, e_2, \dots, e_{m_i}$ ( $\le e_j \le n$ , $e_j \ne i$ ) — the indices of potions needed to mix a potion of the type $i$ . If this list is empty, then a potion of the type $i$ can only be bought.

It is guaranteed that no potion can be obtained from itself through one or more mixing processes.

It is guaranteed that the sum of all $n$ values across all test cases does not exceed $\cdot 10^5$ . Similarly, it is guaranteed that the sum of all $m_i$ values across all test cases does not exceed $\cdot 10^5$ .

Output

For each test case, output $n$ integers — the minimum number of coins Nastya needs to spend to obtain a potion of each type.

Example
input1

4
5 1
30 8 3 5 10
3
3 2 4 5
0 
0 
2 3 5
0 
3 2
5 143 3
1 3
1 2
0 
2 1 2
5 1
5 4 1 3 4
2
2 4 5
3 3 5 4
2 1 4
1 5
0 
4 2
1 1 5 4
2 4
3 2 4 3
0 
2 2 4
1 2

output1

23 8 0 5 10 
0 143 0 
5 0 1 3 4 
0 0 0 0

input2

3
6 3
5 5 4 5 2 2
3 4 5
2 2 5
1 5
3 4 1 6
4 2 6 1 5
0 
0 
6 2
1 4 4 1 5 2
3 6
4 6 3 4 5
4 6 5 3 4
0 
1 5
1 6
0 
2 1
4 3
1
0 
1 1

output2

0 0 0 0 0 2 
0 0 0 0 0 0 
0 0

Note

In the first test case of the first sample, it is optimal:

Get a potion of the first type by buying and mixing $2$ , $4$ and $5$ ;
a potion of the second type can only be obtained by purchasing it;
Nastya already has an unlimited number of potions of the third type;
a potion of the fourth type is more profitable to buy than to buy and mix other potions;
a potion of the fifth type can only be obtained by purchasing it.

Tutorial
先将免费的药水进行标记，再对每一种药水采用 DFS 判断合成每种药水的价格

Solution

#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define int long long

int n, m, x, y;

void solve() {
    cin >> n >> m;
    vector<int> a(n + 1), ans(n + 1);
    vector<bool> memo(n + 1);
    vector<vector<int>> all;
    for (int i = 1; i <= n; ++i) {
        cin >> a[i];
    }
    while (m--) {
        cin >> x;
        a[x] = 0;
    }
    all.push_back({});
    for (int i = 1; i <= n; ++i) {
        cin >> x;
        vector<int> mid(x);
        for (int j = 0; j < x; ++j) {
            cin >> mid[j];
        }
        all.emplace_back(mid);
    }
    for (int i = 1; i <= n; ++i) {
        if (a[i] == 0) {
            ans[i] = 0;
            memo[i] = true;
        }
    }

    function<void(int)> dfs = [&](int x) {
        for (int y : all[x]) {
            if (!memo[y]) {
                dfs(y);
            }
            ans[x] += ans[y];
        }
        if (all[x].empty()) {
            ans[x] = a[x];
        }
        ans[x] = min(ans[x], a[x]);
        memo[x] = true;
    };

    for (int i = 1; i <= n; ++i) {
        if (!memo[i]) {
            dfs(i);
        }
        cout << ans[i] << " \n"[i == n];
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T; cin >> T; while (T--)
    solve();
    return 0;
}

F. Lisa and the Martians

time limit per test: 3 second memory limit per test: 512 megabytes input: standard input outputL: standard output

Lisa was kidnapped by martians! It okay, because she has watched a lot of TV shows about aliens, so she knows what awaits her. Let’s call integer martian if it is a non-negative integer and strictly less than $2^k$ , for example, when $k = 12$ , the numbers $51$ , $1960$ , $0$ are martian, and the numbers $\pi$ , $- 1$ , $\frac{21}{8}$ , $4096$ are not.

The aliens will give Lisa $n$ martian numbers $a_1, a_2, \ldots, a_n$ . Then they will ask her to name any martian number $x$ . After that, Lisa will select a pair of numbers $a_i, a_j$ ( $\neq j$ ) in the given sequence and count $(a_i \oplus x) \& (a_j \oplus x)$ . The operation $\oplus$ means Bitwise exclusive OR, the operation $\&$ means Bitwise And. For example, $\oplus 17) \& (23 \oplus 17) = (00101_2 \oplus 10001_2) \& (10111_2 \oplus 10001_2) = 10100_2 \& 00110_2 = 00100_2 = 4$ .

Lisa is sure that the higher the calculated value, the higher her chances of returning home. Help the girl choose such $i, j, x$ that maximize the calculated value.

Input

The first line contains an integer $t$ ( $\le t \le 10^4$ ) — number of testcases.

Each testcase is described by two lines.

The first line contains integers $n, k$ ( $\le n \le 2 \cdot 10^5$ , $\le k \le 30$ ) — the length of the sequence of martian numbers and the value of $k$ .

The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ( $\le a_i < 2^k$ ) — a sequence of martian numbers.

It is guaranteed that the sum of $n$ over all testcases does not exceed $\cdot 10^5$ .

Output

For each testcase, print three integers $i, j, x$ ( $\le i, j \le n$ , $\neq j$ , $\le x < 2^k$ ). The value of $(a_i \oplus x) \& (a_j \oplus x)$ should be the maximum possible.

If there are several solutions, you can print any one.

Example
input

10
5 4
3 9 1 4 13
3 1
1 0 1
6 12
144 1580 1024 100 9 13
4 3
7 3 0 4
3 2
0 0 1
2 4
12 2
9 4
6 14 9 4 4 4 5 10 2
2 1
1 0
2 4
11 4
9 4
2 11 10 1 6 9 11 0 5

output

Note

First testcase: $\oplus 14) \& (1 \oplus 14) = (0011_2 \oplus 1110_2) \& (0001_2 \oplus 1110_2) = 1101_2 = 1101_2 \& 1111_2 = 1101_2 = 13$ .

Second testcase: $\oplus 0) \& (1 \oplus 0) = 1$ .

Third testcase: $\oplus 4082) \& (13 \oplus 4082) = 4091$ .

Fourth testcase: $\oplus 7) \& (0 \oplus 7) = 4$ .

Tutorial
排序找到相邻数异或最小的位置，因为相邻位置的数异或在二进制表示上是最小的

官方题解：
按非降序对 $a_1, a_2, \ldots, a_n$ 进行排序。我们将证明答案是一对相邻的数字。设答案为数字 $a_i, a_j$ ( $j - i > 1$ )。如果 $a_i = a_j$ ，则 $a_i = a_{i + 1}$ 。否则，它们具有共同的位前缀，后面有不同的位。也就是说，在某个位置 $t$ ， $a_i$ 有 $0$ ， $a_j$ 有 $1$ 。由于 $j - i > 1$ 、 $a_{i + 1}$ 在该位置可以有 $0$ 或 $1$ ，但第一种情况选择 $a_i, a_{i + 1}$ 更有利，第二种情况选择 $a_{i + 1}, a_j$ 更有利。选择 $a_{i + 1}, a_j$ 作为答案。该解的复杂度为 $\log n)$

Solution

#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define int long long

void solve() {
    int n, k, x, ans, mn, mid;
    cin >> n >> k;
    vector<PII> all;
    ans = 0;
    for (int i = 0; i < n; ++i) {
        cin >> x;
        all.emplace_back(x, i);
    }
    ranges::sort(all);
    mn = all[0].fi ^ all[1].fi;
    for (int i = 2; i < n; ++i) {
        mid = all[i].fi ^ all[i - 1].fi;
        if (mid < mn) {
            mn = mid;
            ans = i - 1;
        }
    }
    cout << all[ans].se + 1 << " " << all[ans + 1].se + 1 << " " << (1 << k) - 1 - all[ans].fi << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T; cin >> T; while (T--)
    solve();
    return 0;
}

G. Vlad and the Mountains

time limit per test: 5 second memory limit per test: 512 megabytes input: standard input outputL: standard output

Vlad decided to go on a trip to the mountains. He plans to move between $n$ mountains, some of which are connected by roads. The $i$ -th mountain has a height of $h_i$ .

If there is a road between mountains $i$ and $j$ , Vlad can move from mountain $i$ to mountain $j$ by spending $h_j - h_i$ units of energy. If his energy drops below zero during the transition, he will not be able to move from mountain $i$ to mountain $j$ . Note that $h_j - h_i$ can be negative and then the energy will be restored.

Vlad wants to consider different route options, so he asks you to answer the following queries: is it possible to construct some route starting at mountain $a$ and ending at mountain $b$ , given that he initially has $e$ units of energy?

Input

The first line of the input contains an integer $t$ ( $\le t \le 10^4$ ) — the number of test cases.

The descriptions of the test cases follow.

The first line of each test case contains two numbers $n$ and $m$ ( $\le n \le 2 \cdot 10^5$ , $\le m \le \min(\frac{n\cdot(n - 1)}{2}, 2 \cdot 10^5)$ ) — the number of mountains and the number of roads between them, respectively.

The second line contains $n$ integers $h_1, h_2, h_3, \dots, h_n$ ( $\le h_i \le 10^9$ ) — the heights of the mountains.

The next $m$ lines contain two integers $u$ and $v$ ( $\le u, v \le n$ , $\ne v$ ) — the numbers of the mountains connected by a road. It is guaranteed that no road appears twice.

The next line contains an integer $q$ ( $\le q \le 2 \cdot 10^5$ ) — the number of queries.

The following $q$ lines contain three numbers $a$ , $b$ , and $e$ ( $\le a, b \le n$ , $\le e \le 10^9$ ) — the initial and final mountains of the route, and the amount of energy, respectively.

It is guaranteed that the sum of $n$ over all test cases does not exceed $\cdot 10^5$ . The same guarantee applies to $m$ and $q$ .

Output

For each query, output “YES” if Vlad can construct a route from mountain $a$ to mountain $b$ , and “NO” otherwise.

You can output the answer in any case (for example, the strings “yEs”, “yes”, “Yes”, and “YES” will be recognized as a positive answer).

In the examples below, the answers for different test cases are separated by an empty line, which you do not need to output.

Example
input1

2
7 7
1 5 3 4 2 4 1
1 4
4 3
3 6
3 2
2 5
5 6
5 7
5
1 1 3
6 2 0
4 7 0
1 7 4
1 7 2
6 5
4 7 6 2 5 1
1 3
5 3
1 5
2 4
6 2
5
1 5 1
1 3 1
1 2 1000
6 2 6
6 2 5

output1

YES
NO
YES
YES
NO

YES
NO
NO
YES
NO

input2

output2

YES
NO
YES
YES
NO

YES
NO
NO
YES
NO

input3

output3

YES
YES
YES
YES
NO

YES
YES
YES
YES
YES

Tutorial
由题意得，从顶点 $i$ 出发，有可能到达任何不经过高度大于 $h_a + e$ 的顶点的路径，因此需要对每个查询，从 $a$ 构建一个集合，其中包含所有高度不大于 $h_a + e$ 的顶点，查看 $b$ 是否在其中，此时需要维护一个并查集
在每个查询前，添加所有没有添加的边，并对与这个特定查询，它们的 $max(h_u, h_v)$ 不大于 $h_a+e$ ，此后，只需检查顶点 $a$ 和 $b$ 是否属于同一连通分量

Solution

#include <bits/stdc++.h>
using namespace std;

#define endl '\n'
#define int long long

void solve() {
    int n, m, u, v, e, q, a, b;
    cin >> n >> m;
    vector<int> h(n + 1), g[n + 1], p(n + 1, -1);
    vector<tuple<int, int, int, int>> all;
    for (int i = 1; i <= n; ++i) {
        cin >> h[i];
        all.emplace_back(h[i], -1, i, 0);
    }
    for (int i = 0; i < m; ++i) {
        cin >> u >> v;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }
    cin >> q;
    vector<bool> ans(q);
    for (int i = 0; i < q; ++i) {
        cin >> u >> v >> e;
        all.emplace_back(h[u] + e, i, u, v);
    }
    ranges::sort(all);

    function<int(int)> dfs = [&](int x) -> int {
        return p[x] < 0 ? x : p[x] = dfs(p[x]);
    };

    for (auto [_, idx, u, v] : all) {
        if (idx == -1) {
            for (int v : g[u]) {
                if (h[v] <= h[u]) {
                    a = dfs(u), b = dfs(v);
                    if (a != b) {
                        if (a < b) {
                            swap(a, b);
                        }
                        p[b] += p[a];
                        p[a] = b;
                    }
                }
            }
        } else {
            ans[idx] = (dfs(u) == dfs(v));
        }
    }
    for (bool flag : ans) {
        cout << (flag ? "YES\n" : "NO\n");
    }
    cout << endl;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T; cin >> T; while (T--)
    solve();
    return 0;
}