Educational Codeforces Round 158 (Rated for Div. 2) 的 A~E 题

A. Line Trip

Description

There is a road, which can be represented as a number line. You are located in the point $0$ of the number line, and you want to travel from the point $0$ to the point $x$, and back to the point $0$.

You travel by car, which spends $1$ liter of gasoline per $1$ unit of distance travelled. When you start at the point $0$, your car is fully fueled (its gas tank contains the maximum possible amount of fuel).

There are $n$ gas stations, located in points $a_1,a_2,\dots ,a_n$. When you arrive at a gas station, you fully refuel your car. Note that you can refuel only at gas stations, and there are no gas stations in points $0$ and $x$.

You have to calculate the minimum possible volume of the gas tank in your car (in liters) that will allow you to travel from the point $0$ to the point $x$ and back to the point $0$.

Input

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

Each test case consists of two lines:

• the first line contains two integers $n$ and $x$ ($1\le n\le 50$; $2\le x\le 100$);
• the second line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($0<a_1<a_2<\cdots <a_n<x$).

Output

For each test case, print one integer — the minimum possible volume of the gas tank in your car that will allow you to travel from the point $0$ to the point $x$ and back.

Example

3
3 7
1 2 5
3 6
1 2 5
1 10
7

4
3
7

Note

In the first test case of the example, if the car has a gas tank of $4$ liters, you can travel to $x$ and back as follows:

• travel to the point $1$, then your car’s gas tank contains $3$ liters of fuel;
• refuel at the point $1$, then your car’s gas tank contains $4$ liters of fuel;
• travel to the point $2$, then your car’s gas tank contains $3$ liters of fuel;
• refuel at the point $2$, then your car’s gas tank contains $4$ liters of fuel;
• travel to the point $5$, then your car’s gas tank contains $1$ liter of fuel;
• refuel at the point $5$, then your car’s gas tank contains $4$ liters of fuel;
• travel to the point $7$, then your car’s gas tank contains $2$ liters of fuel;
• travel to the point $5$, then your car’s gas tank contains $0$ liters of fuel;
• refuel at the point $5$, then your car’s gas tank contains $4$ liters of fuel;
• travel to the point $2$, then your car’s gas tank contains $1$ liter of fuel;
• refuel at the point $2$, then your car’s gas tank contains $4$ liters of fuel;
• travel to the point $1$, then your car’s gas tank contains $3$ liters of fuel;
• refuel at the point $1$, then your car’s gas tank contains $4$ liters of fuel;
• travel to the point $0$, then your car’s gas tank contains $3$ liters of fuel.

---

Solution

通过贪心的思想，油最少的时候必定是到达一个加油站还未加油的时候，所以最多的消耗为两两加油站之间的距离中最大值。

注意：因为还会折回来，所以要么破环成链，要么特判终点到最后一个加油站的距离乘 $2$。

---

Code

#include <iostream>
#include <vector>
#define int long long

using namespace std;

typedef pair<int, int> PII;

void solve()
{
	int N, X;

	cin >> N >> X;

	std::vector<int> A(N + 1);
	for (int i = 1; i <= N; i ++)
		cin >> A[i];

	int Result = 0;
	for (int i = 1; i <= N; i ++)
		Result = max(Result, A[i] - A[i - 1]);
	Result = max(Result, (X - A[N]) * 2);

	cout << Result << endl;
}

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	int Data;

	cin >> Data;

	while (Data --)
		solve();

	return 0;
}

B. Chip and Ribbon

Description

There is a ribbon divided into $n$ cells, numbered from $1$ to $n$ from left to right. Initially, an integer $0$ is written in each cell.

Monocarp plays a game with a chip. The game consists of several turns. During the first turn, Monocarp places the chip in the $1$-st cell of the ribbon. During each turn except for the first turn, Monocarp does exactly one of the two following actions:

• move the chip to the next cell (i. e. if the chip is in the cell $i$, it is moved to the cell $i+1$). This action is impossible if the chip is in the last cell;
• choose any cell $x$ and teleport the chip into that cell. It is possible to choose the cell where the chip is currently located.

At the end of each turn, the integer written in the cell with the chip is increased by $1$.

Monocarp’s goal is to make some turns so that the $1$-st cell contains the integer $c_1$, the $2$-nd cell contains the integer $c_2$, …, the $n$-th cell contains the integer $c_n$. He wants to teleport the chip as few times as possible.

Help Monocarp calculate the minimum number of times he has to teleport the chip.

Input

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

Each test case consists of two lines:

• the first line contains one integer $n$ ($1\le n\le 2\cdot 10^5$);
• the second line contains $n$ integers $c_1,c_2,\dots ,c_n$ ($0\le c_i\le 10^9$; $c_1\ge 1$).

It can be shown that under these constraints, it is always possible to make a finite amount of turns so that the integers in the cells match the sequence $c_1,c_2,\dots ,c_n$.

Additional constraint on the input: the sum of values of $n$ over all test cases does not exceed $2\cdot 10^5$.

Output

For each test case, print one integer — the minimum number of times Monocarp has to teleport the chip.

Example

4
4
1 2 2 1
5
1 0 1 0 1
5
5 4 3 2 1
1
12

1
2
4
11

Note

In the first test case of the example, Monocarp can perform the turns as follows:

• place the chip in the $1$-st cell; the numbers in the cells are $[1,0,0,0]$;
• move the chip to the next ($2$-nd) cell; the numbers in the cells are $[1,1,0,0]$;
• move the chip to the next ($3$-rd) cell; the numbers in the cells are $[1,1,1,0]$;
• teleport the chip to the $2$-nd cell; the numbers in the cells are $[1,2,1,0]$;
• move the chip to the next ($3$-rd) cell; the numbers in the cells are $[1,2,2,0]$;
• move the chip to the next ($4$-th) cell; the numbers in the cells are $[1,2,2,1]$.

---

Solution

若当前为第 $i$ 个数，需跳到该点的次数为 $\max (0,A_i-A_{i-1})$

解释：因为前面的点一定会先一步变成 $0$，这时候该点就无法通过上一个点转移而来，那么就只能用跳转的方式来进行减的操作，所以轮数（代价）即为 $\max (0,A_i-A_{i-1})$

---

Code

#include <iostream>
#define int long long

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 2e5 + 10;

int N;
int A[SIZE];

void solve()
{
	cin >> N;

	for (int i = 1; i <= N; i ++)
		cin >> A[i];

	int Last = 0, Result = 0;
	for (int i = 1; i <= N; i ++)
	{
		if (Last < A[i])
			Result += A[i] - Last;
		Last = A[i];
	}

	cout << Result - 1 << endl;
}

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	int Data;

	cin >> Data;

	while (Data --)
		solve();

	return 0;
}

C. Add, Divide and Floor

Description

You are given an integer array $a_1,a_2,\dots ,a_n$ ($0\le a_i\le 10^9$). In one operation, you can choose an integer $x$ ($0\le x\le 10^{18}$) and replace $a_i$ with $\lfloor \frac{a_i+x}{2}\rfloor$ ($\lfloor y\rfloor$ denotes rounding $y$ down to the nearest integer) for all $i$ from $1$ to $n$. Pay attention to the fact that all elements of the array are affected on each operation.

Print the smallest number of operations required to make all elements of the array equal.

If the number of operations is less than or equal to $n$, then print the chosen $x$ for each operation. If there are multiple answers, print any of them.

Input

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

The first line of each testcase contains a single integer $n$ ($1\le n\le 2\cdot 10^5$).

The second line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($0\le a_i\le 10^9$).

The sum of $n$ over all testcases doesn’t exceed $2\cdot 10^5$.

Output

For each testcase, print the smallest number of operations required to make all elements of the array equal.

If the number of operations is less than or equal to $n$, then print the chosen $x$ for each operation in the next line. If there are multiple answers, print any of them.

Example

4
1
10
2
4 6
6
2 1 2 1 2 1
2
0 32

0
2
2 5
1
1
6

Note

In the first testcase, all elements are already equal, so $0$ operations are required. It doesn’t matter if you print an empty line afterwards or not.

In the second testcase, you can’t make less than $2$ operations. There are multiple answers, let’s consider the answer sequence $[2,5]$. After applying an operation with $x=2$, the array becomes $[\lfloor \frac{4+2}{2}\rfloor ,\lfloor \frac{6+2}{2}\rfloor ]=[3,4]$. After applying an operation with $x=5$ after that, the array becomes $[\lfloor \frac{3+5}{2}\rfloor ,\lfloor \frac{4+5}{2}\rfloor ]=[4,4]$. Both elements are the same, so we are done.

In the last testcase, you can’t make less than $6$ operations. Since $6$ is greater than $n$, you don’t have to print them. One possible answer sequence is $[0,0,0,0,0,0]$. We are just dividing the second element by $2$ every time and not changing the first element.

---

Solution

对于这种要求区间全部相同的题目，可以观察最大值与最小值的关系，因为如果最大值和最小值相同，则说明区间内的数全部相同。

每一次操作，$x$ 只为 $0$ 或 $1$ 即可，因为如果是偶数就相当于 $0$，反之如果是奇数就相当于 $1$。

所以只用探讨最大值($r$)和最小值($l$)的奇偶性即可：

• 最小值为偶数，最大值为偶数：$x$ 取 $0$ 或 $1$ 都是最优的，因为观察最大值和最小值的差可知：

  • $x$ 取 $0$：$\frac{r}{2}-\frac{l}{2}=\frac{r-l}{2}$
  • $x$ 取 $1$：$\lfloor \frac{r+1}{2}\rfloor -\lfloor \frac{l+1}{2}\rfloor =\frac{r-l}{2}$

• 最小值为偶数，最大值为奇数： $x$ 取 $0$ 是最优的，因为观察最大值和最小值的差可知：

  • $x$ 取 $0$：$\lfloor \frac{r}{2}\rfloor -\frac{l}{2}=\frac{r-1-l}{2}$
  • $x$ 取 $1$：$\frac{r+1}{2}-\lfloor \frac{l+1}{2}\rfloor =\frac{r-l+1}{2}$

• 最小值为奇数，最大值为偶数： $x$ 取 $1$ 是最优的，因为观察最大值和最小值的差可知：

  • $x$ 取 $0$：$\frac{r}{2}-\lfloor \frac{l}{2}\rfloor =\frac{r-l+1}{2}$
  • $x$ 取 $1$：$\lfloor \frac{r+1}{2}\rfloor -\frac{l+1}{2}=\frac{r-l-1}{2}$

• 最小值为奇数，最大值为奇数： $x$ 取 $0$ 或 $1$ 都是最优的，因为观察最大值和最小值的差可知：

  • $x$ 取 $0$：$\lfloor \frac{r}{2}\rfloor -\lfloor \frac{l}{2}\rfloor =\frac{r-l}{2}$

  • $x$ 取 $1$：$\frac{r+1}{2}-\frac{l+1}{2}=\frac{r-l}{2}$

综上所述，当最小值是奇数时，$x$ 取 $1$，反之取 $0$。

---

Code

#include <iostream>
#include <set>
#include <vector>
#define int long long

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 2e5 + 10;

int N;
int A[SIZE];

void solve()
{
	cin >> N;

	int Min = 1e18, Max = 0;
	for (int i = 1; i <= N; i ++)
		cin >> A[i], Min = min(Min, A[i]), Max = max(Max, A[i]);

	std::vector<int> Op;
	while (Min != Max)
	{
		int Add = Min & 1;
		Op.push_back(Add);
		Min = Min + Add >> 1;
		Max = Max + Add >> 1;
	}

	cout << Op.size() << endl;
	if (Op.size() <= N && Op.size())
	{
		for (auto c : Op)
			cout << c << " ";
		cout << endl;
	}
}

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	int Data;

	cin >> Data;

	while (Data --)
		solve();

	return 0;
}

D. Yet Another Monster Fight

Description

Vasya is a sorcerer that fights monsters. Again. There are $n$ monsters standing in a row, the amount of health points of the $i$-th monster is $a_i$.

Vasya is a very powerful sorcerer who knows many overpowered spells. In this fight, he decided to use a chain lightning spell to defeat all the monsters. Let’s see how this spell works.

Firstly, Vasya chooses an index $i$ of some monster ($1\le i\le n$) and the initial power of the spell $x$. Then the spell hits monsters exactly $n$ times, one hit per monster. The first target of the spell is always the monster $i$. For every target except for the first one, the chain lightning will choose a random monster who was not hit by the spell and is adjacent to one of the monsters that already was hit. So, each monster will be hit exactly once. The first monster hit by the spell receives $x$ damage, the second monster receives $(x-1)$ damage, the third receives $(x-2)$ damage, and so on.

Vasya wants to show how powerful he is, so he wants to kill all the monsters with a single chain lightning spell. The monster is considered dead if the damage he received is not less than the amount of its health points. On the other hand, Vasya wants to show he doesn’t care that much, so he wants to choose the minimum initial power of the spell $x$ such that it kills all monsters, no matter which monster (among those who can get hit) gets hit on each step.

Of course, Vasya is a sorcerer, but the amount of calculations required to determine the optimal spell setup is way above his possibilities, so you have to help him find the minimum spell power required to kill all the monsters.

Note that Vasya chooses the initial target and the power of the spell, other things should be considered random and Vasya wants to kill all the monsters even in the worst possible scenario.

Input

The first line of the input contains one integer $n$ ($1\le n\le 3\cdot 10^5$) — the number of monsters.

The second line of the input contains $n$ integers $a_1,a_2,\dots ,a_n$ ($1\le a_i\le 10^9$), where $a_i$ is the amount of health points of the $i$-th monster.

Output

Print one integer — the minimum spell power required to kill all the monsters if Vasya chooses the first target optimally, and the order of spell hits can be any possible within the given rules.

Example

6
2 1 5 6 4 3

8

---

Solution

考虑假设我们知道初始位置为 $i$，对于每一个位置 $j$：

• 如果 $j<i$，那么最坏情况是从 $i$ 往右打，再往左打回来，也就是打了 $n-j$ 个，所以需要的初始能量至少为 $a_j+n-j$
• 如果 $j>i$，那么最坏情况是从 $i$ 往左打，再往右打到 $j$，也就是打了 $j-1$ 个，所以需要的初始能量至少为 $a_j+j-1$

最后的结果为 $\max ({\max }_{j=1}^{i-1}{a}_j+n-j,{\max }_{j=i+1}^n{a}_j+j-1,a_i)$，但是这样的时间复杂度是 $O(n^2)$ 的，所以需要优化。

可以使用前缀和预处理前两项。

---

Code

#include <iostream>
#define int long long

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 3e5 + 10;

int N;
int A[SIZE];
int Pre[SIZE], Suf[SIZE];

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	cin >> N;

	for (int i = 1; i <= N; i ++)
	{
		cin >> A[i];
		Pre[i] = A[i] + (N - i);
		Suf[i] = A[i] + (i - 1);
	}

	for (int i = 1; i <= N; i ++)
		Pre[i] = max(Pre[i], Pre[i - 1]);
	for (int i = N; i >= 1; i --)
		Suf[i] = max(Suf[i], Suf[i + 1]);

	int Result = 1e18;
	for (int i = 1; i <= N; i ++)
	{
		int Cost = max(A[i], max(Pre[i - 1], Suf[i + 1]));
		Result = min(Result, Cost);
	}

	cout << Result << endl;

	return 0;
}

E. Compressed Tree

Description

You are given a tree consisting of $n$ vertices. A number is written on each vertex; the number on vertex $i$ is equal to $a_i$.

You can perform the following operation any number of times (possibly zero):

• choose a vertex which has at most $1$ incident edge and remove this vertex from the tree.

Note that you can delete all vertices.

After all operations are done, you’re compressing the tree. The compression process is done as follows. While there is a vertex having exactly $2$ incident edges in the tree, perform the following operation:

• delete this vertex, connect its neighbors with an edge.

It can be shown that if there are multiple ways to choose a vertex to delete during the compression process, the resulting tree is still the same.

Your task is to calculate the maximum possible sum of numbers written on vertices after applying the aforementioned operation any number of times, and then compressing the tree.

Input

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

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

The second line contains $n$ integers $a_1,a_2,\dots ,a_n$ ($-10^9\le a_i\le 10^9$).

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

Additional constraint on the input: the sum of $n$ over all test cases doesn’t exceed $5\cdot 10^5$.

Output

For each test case, print a single integer — the maximum possible sum of numbers written on vertices after applying the aforementioned operation any number of times, and then compressing the tree.

Example

3
4
1 -2 2 1
1 2
3 2
2 4
2
-2 -5
2 1
7
-2 4 -2 3 3 2 -1
1 2
2 3
3 4
3 5
4 6
4 7

3
0
9

---

Solution

可以看这位大佬的讲解，懒得写了，咕咕咕

E

---

Code

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
#define int long long

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 5e5 + 10;

int N;
int A[SIZE];
std::vector<int> G[SIZE];
int Result, F[SIZE];

void DFS(int u, int fa)
{
	Result = max(Result, A[u]), F[u] = A[u];

	vector<int> V;
	for (auto v : G[u])
	{
		if (v == fa) continue;
		DFS(v, u);
		V.push_back(F[v]);
	}

	sort(V.begin(), V.end());

	if (V.size() >= 1)
	{
		F[u] = max(F[u], V.back());
		Result = max(Result, V.back() + A[u]);
	}
	if (V.size() >= 2)
	{
		F[u] = max(F[u], V.back() + V[V.size() - 2] + A[u]);
		Result = max(Result, V.back() + V[V.size() - 2]);
	}
	if (V.size() >= 3)
	{
		int Val = A[u], Count = 0, M1 = -1e18, M2 = -1e18;
		for (auto c : V)
			if (c >= 0)
				Val += c, Count ++;
			else
				if (c > M1)
					M2 = M1, M1 = c;
				else if (c > M2)
					M2 = c;

		if (Count >= 3)
			F[u] = max(F[u], Val), Result = max(Result, Val);
		else if (Count == 2)
			F[u] = max(F[u], M1 + Val), Result = max(Result, M1 + Val);
		else if (Count == 1)
			F[u] = max(F[u], M1 + M2 + Val), Result = max(Result, M1 + M2 + Val);
	}
}

void solve()
{
	cin >> N;

	for (int i = 1; i <= N; i ++)
		cin >> A[i];

	int u, v;
	for (int i = 1; i < N; i ++)
		cin >> u >> v, G[u].push_back(v), G[v].push_back(u);

	DFS(1, -1);

	cout << Result << endl;

	for (int i = 1; i <= N; i ++)
		G[i].clear(), F[i] = 0;
	Result = 0;
}

signed main()
{
	cin.tie(0);
	cout.tie(0);
	ios::sync_with_stdio(0);

	int Data;

	cin >> Data;

	while (Data --)
		solve();

	return 0;
}