Codeforces Round 933 (Div. 3)

InHng

已于 2024-03-12 17:23:23 修改

阅读量1k

点赞数 14

文章标签： c++ 算法数据结构 python Codeforces

于 2024-03-12 16:08:31 首次发布

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

版权

A. Rudolf and the Ticket

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

Rudolf is going to visit Bernard, and he decided to take the metro to get to him. The ticket can be purchased at a machine that accepts exactly two coins, the sum of which does not exceed $k$ .

Rudolf has two pockets with coins. In the left pocket, there are $n$ coins with denominations $b_1, b_2, \dots, b_n$ . In the right pocket, there are $m$ coins with denominations $c_1, c_2, \dots, c_m$ . He wants to choose exactly one coin from the left pocket and exactly one coin from the right pocket (two coins in total).

Help Rudolf determine how many ways there are to select indices $f$ and $s$ such that $b_f + c_s \le k$ .

Input

The first line contains an integer $t$ ( $\le t \le 100$ ) — the number of test cases. Then follows the description of each test case.

The first line of each test case contains three natural numbers $n$ , $m$ , and $k$ ( $\le n, m \le 100, 1 \le k \le 2000$ ) — the number of coins in the left and right pockets, and the maximum sum of two coins for the ticket payment at the counter, respectively.

The second line of each test case contains $n$ integers $b_i$ ( $\le b_i \le 1000$ ) — the denominations of coins in the left pocket.

The third line of each test case contains $m$ integers $c_i$ ( $\le c_i \le 1000$ ) — the denominations of coins in the right pocket.

Output

For each testcase, output a single integer — the number of ways Rudolf can select two coins, taking one from each pocket, so that the sum of the coins does not exceed $k$ .

Example

input

output

Note

Note that the pairs indicate the indices of the coins in the array, not their denominations.

In the first test case, Rudolf can choose the following pairs of coins: $[1, 1], [1, 2], [1, 4], [2, 1], [2, 2], [2, 4]$ .

In the second test case, Rudolf cannot choose one coin from each pocket in any way, as the sum of any two elements from the first and second arrays will exceed the value of $k = 4$ .

In the third test case, Rudolf can choose: $[1, 1], [2, 1], [3, 1], [4, 1]$ .

In the fourth test case, Rudolf can choose any coin from the left pocket and any coin from the right pocket.

Tutorial

第一题怎么快怎么来，直接暴力循环破解

Solution

for _ in range(int(input())):
    n, m, k = map(int, input().split())
    b = list(map(int, input().split()))
    c = list(map(int, input().split()))
    print(sum(b[i] + c[j] <= k for j in range(m) for i in range(n)))

B. Rudolf and 121

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

Rudolf has an array $a$ of $n$ integers, the elements are numbered from $1$ to $n$ .

In one operation, he can choose an index $i$ ( $\le i \le n - 1$ ) and assign:

$a_{i - 1} = a_{i - 1} - 1$
$a_i = a_i - 2$
$a_{i + 1} = a_{i + 1} - 1$

Rudolf can apply this operation any number of times. Any index $i$ can be used zero or more times.

Can he make all the elements of the array equal to zero using this operation?

Input

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

The first line of each case contains a single integer $n$ ( $\le n \le 2 \cdot 10^5$ ) — the number of elements in the array.

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

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

Output

For each test case, output “YES” if it is possible to make all the elements of the array zero using the described operations. Otherwise, output “NO”.

You can output each letter in any case (lowercase or uppercase). For example, the strings “yEs”, “yes”, “Yes”, and “YES” will be accepted as a positive answer.

Example

input

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

output

YES
NO
YES
NO
NO
NO
NO

Note

In the first example, the original array is $[1, 3, 5, 5, 2]$ , to make all its elements zero, Rudolf can act as follows:

apply the operation at $i = 4$ and get the array $[1, 3, 4, 3, 1]$ ;
apply the operation at $i = 3$ and get the array $[1, 2, 2, 2, 1]$ ;
apply the operation at $i = 2$ and get the array $[0, 0, 1, 2, 1]$ ;
apply the operation at $i = 4$ and get the array $[0, 0, 0, 0, 0]$ .

Tutorial

可以将题目中的操作变形为：

$a_{i} = a_{i} - 1$
$a_{i + 1} = a_{i + 1} - 2$
$a_{i + 2} = a_{i + 2} - 1$

所以可以直接一次从最左边的元素直接遍历到倒数第三个元素，最后判断最后两个数是否为 0 即可

Solution

for _ in range(int(input())):
    n = int(input())
    a = list(map(int, input().split()))
    ans = "YES"
    for i in range(n - 2):
        if a[i] >= 0:
            a[i + 1] -= a[i] * 2
            a[i + 2] -= a[i]
            a[i] = 0
        else:
            ans = "NO"
            break
    if a[-1] or a[-2]:
        ans = "NO"
    print(ans)

C. Rudolf and the Ugly String

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

Rudolf has a string $s$ of length $n$ . Rudolf considers the string $s$ to be ugly if it contains the substring $^\dagger$ “pie” or the substring “map”, otherwise the string $s$ will be considered beautiful.

For example, “ppiee”, “mmap”, “dfpiefghmap” are ugly strings, while “mathp”, “ppiiee” are beautiful strings.

Rudolf wants to shorten the string $s$ by removing some characters to make it beautiful.

The main character doesn’t like to strain, so he asks you to make the string beautiful by removing the minimum number of characters. He can remove characters from any positions in the string (not just from the beginning or end of the string).

$^\dagger$ String $a$ is a substring of $b$ if there exists a consecutive segment of characters in string $b$ equal to $a$ .

Input

The first line contains a single 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 a single integer $n$ ( $\le n \le 10^6$ ) — the length of the string $s$ .

The next line of each test case contains the string $s$ of length $n$ . The string $s$ consists of lowercase Latin letters.

The sum of $n$ over all test cases does not exceed $10^6$ .

Output

For each test case, output a single integer — the minimum number of characters that need to be deleted to make the string $s$ beautiful. If the string is initially beautiful, then output $0$ .

Example

input

6
9
mmapnapie
9
azabazapi
8
mappppie
18
mapmapmapmapmapmap
1
p
11
pppiepieeee

output

Note

In the first test case, for example, you can delete the $4$ th and $9$ th characters to make the string beautiful.

In the second test case, the string is already beautiful.

Tutorial

遇到 map 或者 pie 都需要在三个数字中选择一个字母删除，但遇到 mapie 时只需要删除中间的 p 即可，所以答案就是 map 的数量 + pie 的数量 - mapie 的数量

Solution

for _ in range(int(input())):
    n = int(input())
    s = input().strip()
    print(s.count("map") + s.count("pie") - s.count("mapie"))

D. Rudolf and the Ball Game

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

Rudolf and Bernard decided to play a game with their friends. $n$ people stand in a circle and start throwing a ball to each other. They are numbered from $1$ to $n$ in the clockwise order.

Let’s call a transition a movement of the ball from one player to his neighbor. The transition can be made clockwise or counterclockwise.

Let’s call the clockwise (counterclockwise) distance from player $y_1$ to player $y_2$ the number of transitions clockwise (counterclockwise) that need to be made to move from player $y_1$ to player $y_2$ . For example, if $n = 7$ then the clockwise distance from $2$ to $5$ is $3$ , and the counterclockwise distance from $2$ to $5$ is $4$ .

Initially, the ball is with the player number $x$ (players are numbered clockwise). On the $i$ -th move the person with the ball throws it at a distance of $r_i$ ( $\le r_i \le n - 1$ ) clockwise or counterclockwise. For example, if there are $7$ players, and the $2$ nd player, after receiving the ball, throws it a distance of $5$ , then the ball will be caught by either the $7$ th player (throwing clockwise) or the $4$ th player (throwing counterclockwise). An illustration of this example is shown below.

The game was interrupted after $m$ throws due to unexpected rain. When the rain stopped, the guys gathered again to continue. However, no one could remember who had the ball. As it turned out, Bernard remembered the distances for each of the throws and the direction for some of the throws (clockwise or counterclockwise).

Rudolf asks you to help him and based on the information from Bernard, calculate the numbers of the players who could have the ball after $m$ throws.

Input

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

The first line of each test case contains three integers $n, m, x$ ( $\le n \le 1000$ , $\le m \le 1000$ , $\le x \le n$ ) — the number of players, the number of throws made, and the number of the player who threw the ball first, respectively.

The next $m$ lines contain information about each throw in order. Each of them contains an integer $r_i$ ( $\le r_i \le n - 1$ ) — the distance at which the $i$ -th throw was made, and a symbol $c_i$ , equal to ‘0’, ‘1’, or ‘?’:

if $c_i$ =‘0’, then the $i$ -th throw was made clockwise,
if $c_i$ =‘1’, then the $i$ -th throw was made counterclockwise,
if $c_i$ =‘?’, then Bernard does not remember the direction and the $i$ -th throw could have been made either clockwise or counterclockwise.

It is guaranteed that the sum $\cdot m$ ( $n$ multiplied by $m$ ) over all test cases does not exceed $\cdot 10^5$ .

Output

For each test case, output two lines.

In the first line, output the number of players $k$ ( $\le k \le n$ ) who could have the ball at the end of the game.

In the next line, output $k$ numbers $b_i$ ( $\le b_i \le n$ ) — the numbers of the players in increasing order. All numbers must be different.

Example

input

output

Note

Below is an illustration of three throws for the first test case. The arrows denote possible throw directions. Players who could have the ball after the throw are highlighted in gray.

Tutorial

从初始值开始，根据情况暴力模拟出每种情况即可

Solution

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

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

void solve() {
    int n, m, x;
    cin >> n >> m >> x;
    vector<int> now(1, x);
    while (m--) {
        int r;
        char c;
        set<int> s;
        vector<int> mid(now);
        cin >> r >> c;
        if (c == '0') {
            for (int ai : mid) {
                s.insert((ai + r) % n ? (ai + r) % n : n);
            }
        } else if (c == '1') {
            for (int ai : mid) {
                s.insert((ai - r + n) % n ? (ai - r + n) % n : n);
            }
        } else {
            for (int ai : mid) {
                s.insert((ai + r) % n ? (ai + r) % n : n);
                s.insert((ai - r + n) % n ? (ai - r + n) % n : n);
            }
        }
        now.clear();
        for (int ai : s) {
            now.emplace_back(ai);
        }
    }
    cout << now.size() << endl;
    for (int ai : now) {
        cout << ai << " \n"[ai == now.back()];
    }
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

E. Rudolf and k Bridges

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

Bernard loves visiting Rudolf, but he is always running late. The problem is that Bernard has to cross the river on a ferry. Rudolf decided to help his friend solve this problem.

The river is a grid of $n$ rows and $m$ columns. The intersection of the $i$ -th row and the $j$ -th column contains the number $a_{i,j}$ — the depth in the corresponding cell. All cells in the first and last columns correspond to the river banks, so the depth for them is $0$ .

The river may look like this.

Rudolf can choose the row $\ldots, (i,m)$ and build a bridge over it. In each cell of the row, he can install a support for the bridge. The cost of installing a support in the cell $(i, j)$ is $a_{i,j}+1$ . Supports must be installed so that the following conditions are met:

A support must be installed in cell $(i, 1)$ ;
A support must be installed in cell $(i, m)$ ;
The distance between any pair of adjacent supports must be no more than $d$ . The distance between supports $i, j_1)$ and $i, j_2)$ is $j_1 - j_2| - 1$ .

Building just one bridge is boring. Therefore, Rudolf decided to build $k$ bridges on consecutive rows of the river, that is, to choose some $i$ ( $\le i \le n - k + 1$ ) and independently build a bridge on each of the rows $\ldots, i + k - 1$ . Help Rudolf minimize the total cost of installing supports.

Input

The first line contains a single integer $t$ $\le t \le 10^3)$ — the number of test cases. The descriptions of the test cases follow.

The first line of each test case contains four integers $n$ , $m$ , $k$ , and $d$ ( $\le k \le n \le 100$ , $\le m \le 2 \cdot 10^5$ , $\le d \le m$ ) — the number of rows and columns of the field, the number of bridges, and the maximum distance between supports.

Then follow $n$ lines, $i$ -th line contains $m$ positive integers $a_{i, j}$ ( $\le a_{i, j} \le 10^6$ , $a_{i, 1} = a_{i, m} = 0$ ) — the depths of the river cells.

It is guaranteed that the sum of $\cdot m$ for all sets of input data does not exceed $\cdot 10^5$ .

Output

For each test case, output a single number — the minimum total cost of supports installation.

Example

input

5
3 11 1 4
0 1 2 3 4 5 4 3 2 1 0
0 1 2 3 2 1 2 3 3 2 0
0 1 2 3 5 5 5 5 5 2 0
4 4 2 1
0 3 3 0
0 2 1 0
0 1 2 0
0 3 3 0
4 5 2 5
0 1 1 1 0
0 2 2 2 0
0 2 1 1 0
0 3 2 1 0
1 8 1 1
0 10 4 8 4 4 2 0
4 5 3 2
0 8 4 4 0
0 3 4 8 0
0 8 1 10 0
0 10 1 5 0

output

Note

In the first test case, it is most profitable to build a bridge on the second row.

It is not a top view, but side view: gray cells — bridge itself, white cells are empty, black cells — supports, blue cells — water, brown cells — river bottom.

In the second test case, it is most profitable to build bridges on the second and third rows. The supports will be placed in cells $(2, 3)$ , $(3, 2)$ , and on the river banks.

In the third test case the supports can be placed along the river banks.

Tutorial

通过单调队列（可见滑动窗口）计算出每一行建桥所需要的最小价格，再通过前缀和计算出连续 $k$ 行的最小总和

队列前面所有大于窗口大小（长度大于 $d$ ）的值全部 pop 出去，此时第一个值必定是范围内最小的花费，直接加上当前位置的花费后重新 push 进队列中即可，最后遍历队列前面，第一个坐标为 $m - 1$ 的花费即为这一行的最小花费

Solution

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

#define ff first
#define ss second
#define endl '\n'
#define int long long
#define PII pair<int, int>

void solve() {
    int n, m, k, d;
    cin >> n >> m >> k >> d;
    vector<int> pre(n);
    for (int i = 0; i < n; ++i) {
        vector<int> a(m);
        for (int j = 0; j < m; ++j) {
            cin >> a[j];
        }
        priority_queue<PII, vector<PII>, greater<PII>> q;
        q.emplace(1, 0);
        for (int j = 1; j < m; ++j) {
            while (q.size() and q.top().ss < j - d - 1) {
                q.pop();
            }
            q.emplace(q.top().ff + a[j] + 1, j);
        }
        while (q.size() and q.top().ss != m - 1) {
            q.pop();
        }
        pre[i] = q.top().ff;
    }
    int cnt = accumulate(pre.begin(), pre.begin() + k, 0ll);
    int ans = cnt;
    for (int i = k; i < n; ++i) {
        cnt += pre[i] - pre[i - k];
        ans = min(ans, cnt);
    }
    cout << ans << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

F. Rudolf and Imbalance

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

Rudolf has prepared a set of $n$ problems with complexities $a_1 < a_2 < a_3 < \dots < a_n$ . He is not entirely satisfied with the balance, so he wants to add at most one problem to fix it.

For this, Rudolf came up with $m$ models of problems and $k$ functions. The complexity of the $i$ -th model is $d_i$ , and the complexity of the $j$ -th function is $f_j$ . To create a problem, he selects values $i$ and $j$ ( $\le i \le m$ , $\le j \le k$ ) and by combining the $i$ -th model with the $j$ -th function, he obtains a new problem with complexity $d_i + f_j$ (a new element is inserted into the array $a$ ).

To determine the imbalance of the set, Rudolf sorts the complexities of the problems in ascending order and finds the largest value of $a_i - a_{i - 1}$ ( $i > 1$ ).

What is the minimum value of imbalance that Rudolf can achieve by adding at most one problem, created according to the described rules?

Input

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

The first line of each test case contains three integers $n$ , $m$ , and $k$ ( $\le n \le 10^5$ , $\le m, k \le 2 \cdot 10^5$ ) — the number of prepared problems, the number of models, and the number of functions, respectively.

The second line of each test case contains $n$ integers $a_1, a_2, a_3, \dots a_n$ ( $\le a_i \le 2 \cdot 10^9$ , $a_i < a_{i+1}$ ) — the complexities of the prepared problems.

The third line of each test case contains $m$ integers $d_1, d_2, d_3, \dots d_m$ ( $\le d_i \le 10^9$ ) — the complexities of the models.

The fourth line of each test case contains $k$ integers $f_1, f_2, f_3, \dots f_k$ ( $\le f_i \le 10^9$ ) — the complexities of the functions.

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

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

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

Output

For each testcase, output a single number — the minimum imbalance that Rudolf can achieve.

Example

input

7
5 5 5
5 10 15 20 26
11 14 16 13 8
16 4 5 3 1
7 6 5
1 4 7 10 18 21 22
2 3 5 7 4 2
6 8 9 3 2
7 6 5
1 4 7 10 18 21 22
2 3 5 7 4 2
6 8 13 3 2
5 6 3
2 10 13 20 25
11 6 10 16 14 5
6 17 15
4 2 2
11 12 14 15
19 14
10 6
8 4 2
3 10 16 18 21 22 29 30
9 13 16 15
4 2
2 4 7
4 21
4 15 14 5
20 1 15 1 12 5 11

output

Tutorial

二分答案出可能的答案，通过双指针判断出是否能构造出满足题意的值使得数组 $a$ 中的差值满足条件

需要注意只能插入一个值，如果 $a$ 中有两个不同位置的差值都大于 $mi d$ ，则不能满足题意

Solution

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

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

void solve() {
    int n, m, k;
    cin >> n >> m >> k;
    vector<int> a(n), d(m), f(k);
    for (int &ai : a) {
        cin >> ai;
    }
    for (int &di : d) {
        cin >> di;
    }
    for (int &fi : f) {
        cin >> fi;
    }
    sort(d.begin(), d.end());
    sort(f.begin(), f.end());

    function<bool(int)> check = [&](int mid) -> bool {
        int cnt = 0, idx = 0;
        for (int i = 1; i < n; ++i) {
            if (a[i] - a[i - 1] > mid) {
                if (++cnt > 1) { // 需要分割的区间最多只能有一个
                    return false;
                } 
                idx = i;
            }
        }
        if (not cnt) { // 已经满足条件
            return true;
        }
        int down = a[idx] - mid, up = a[idx - 1] + mid; // 肯定是把数组塞到这个区间内
        for (int left = 0, right = k - 1; left < m; ++left) {
            while (~right and d[left] + f[right] > up) {
                --right;
            }
            if (~right and d[left] + f[right] >= down) {
                return true;
            }
        }
        return false;
    };

    
    int left = 0, right = 2e9 + 1;
    while (left + 1 < right) { // 二分答案
        int mid = (left + right) >> 1;
        (check(mid) ? right : left) = mid;
    }
    cout << left + 1 << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

G. Rudolf and Subway

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

Building bridges did not help Bernard, and he continued to be late everywhere. Then Rudolf decided to teach him how to use the subway.

Rudolf depicted the subway map as an undirected connected graph, without self-loops, where the vertices represent stations. There is at most one edge between any pair of vertices.

Two vertices are connected by an edge if it is possible to travel directly between the corresponding stations, bypassing other stations. The subway in the city where Rudolf and Bernard live has a color notation. This means that any edge between stations has a specific color. Edges of a specific color together form a subway line. A subway line cannot contain unconnected edges and forms a connected subgraph of the given subway graph.

An example of the subway map is shown in the figure.

Rudolf claims that the route will be optimal if it passes through the minimum number of subway lines.

Help Bernard determine this minimum number for the given departure and destination stations.

Input

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

This is followed by descriptions of the test cases.

The first line of each test case contains two integers $n$ and $m$ ( $\le n \le 2 \cdot 10^5, 1 \le m \le 2 \cdot 10^5$ ) — the number of subway stations and the number of direct routes between stations (i.e., graph edges).

This is followed by $m$ lines — the description of the edges. Each line of the description contains three integers $u$ , $v$ , and $c$ ( $\le u, v \le n, u \ne v, 1 \le c \le 2 \cdot 10^5$ ) — the numbers of the vertices between which there is an edge, and the color of this edge. It is guaranteed that edges of the same color form a connected subgraph of the given subway graph. There is at most one edge between a pair of any two vertices.

This is followed by two integers $b$ and $e$ ( $\le b, e \le n$ ) — the departure and destination stations.

The sum of all $n$ over all test cases does not exceed $\cdot 10^5$ . The sum of all $m$ over all test cases does not exceed $\cdot 10^5$ .

Output

For each testcase, output a single integer — the minimum number of subway lines through which the route from station $b$ to station $e$ can pass.

Example

input

output

Note

The subway graph for the first example is shown in the figure in the problem statement.

In the first test case, from vertex $1$ to vertex $3$ , you can travel along the path $\rightarrow 2 \rightarrow 3$ , using only the green line.

In the second test case, from vertex $1$ to vertex $6$ , you can travel along the path $\rightarrow 2 \rightarrow 3 \rightarrow 6$ , using the green and blue lines.

In the third test case, there is no need to travel from vertex $6$ to the same vertex, so the number of lines is $0$ .

In the fourth test case, all edges of the graph belong to one line, so the answer is $1$ .

Tutorial

对每个颜色建虚拟点，若在点 $u$ 和点 $v$ 之间有条边，则在其中添加一个新点 $c$ 表示这个条线的颜色，其中点 $u$ 和点 $v$ 到颜色点 $c$ 的距离是 $1$ ，颜色点 $c$ 到点 $u$ 和点 $v$ 的距离是 $0$ ，然后对这个新图进行 $D ijk s t r a$ ，其中初始点 $b$ 的距离为 $0$ ，结束点 $e$ 的距离即为答案

Solution

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

#define ff first
#define ss second
#define endl '\n'
#define int long long
#define PII pair<int, int>

const int INF = 0x3f3f3f3f;

void solve() {
    int n, m, b, e;
    cin >> n >> m;
    vector<vector<PII>> g(n + m + 1);
    map<int, int> mp;
    while (m--) {
        int u, v, c;
        cin >> u >> v >> c;
        if (not mp.count(c)) { // 对每个颜色建一个虚拟点
            mp[c] = ++n;
        }
        // 每到一个新颜色就加一
        g[u].emplace_back(mp[c], 1);
        g[v].emplace_back(mp[c], 1);
        g[mp[c]].emplace_back(u, 0);
        g[mp[c]].emplace_back(v, 0);
    }
    cin >> b >> e;
    function<int()> dijkstra = [&]() -> int {
        priority_queue<PII, vector<PII>, greater<PII>> q;
        vector<int> dis(n + 1, INF);
        vector<bool> memo(n + 1);
        dis[b] = 0;
        q.emplace(0, b);
        while (q.size()) {
            auto [dist, u] =  q.top();
            q.pop();
            if (u == e) {
                return dis[e];
            }
            if (memo[u]) {
                continue;
            }
            memo[u] = true;
            for (auto [v, w] : g[u]) {
                dis[v] = min(dis[v], dist + w);
                q.emplace(dist + w, v);
            }
        }
        return 0;
    };
    
    cout << dijkstra() << endl;
}

signed main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(15);
    int Test; cin >> Test; while (Test--)
    solve();
    return 0;
}

InHng

关注

14
点赞
踩
14

收藏

觉得还不错? 一键收藏
4
评论
Codeforces Round 933 (Div. 3)

A. Rudolf and the Tickettime limit per test: 1 secondmemory limit per test: 256 megabytesinput: standard inputoutput: standard outputRudolf is going to visit Bernard, and he decided to take the metro to get to him. The ticket can be purchased at a ma
复制链接

扫一扫