A - Counting Passes

Description

Problem Statement

$N$ people labeled $1,2,\dots ,N$ took an exam, and person $i$ scored $A_i$ points.
Only those who scored at least $L$ points pass this exam.
Determine how many people out of the $N$ have passed the exam.

Constraints

All input values are integers.
$1\le N\le 100$
$1\le L\le 1000$
$0\le A_i\le 1000$

Input

The input is given from Standard Input in the following format:

$N$ $L$
$A_1$ $A_2$ $\dots$ $A_N$

Output

Print the answer as an integer.

Sample Input 1

5 60
60 20 100 90 40

Sample Output 1

3

Five people took the exam. You need to score at least $60$ points to pass.
Person $1$ scored $60$ points, so they passed.
Person $2$ scored $20$ points, so they did not pass.
Person $3$ scored $100$ points, so they passed.
Person $4$ scored $90$ points, so they passed.
Person $5$ scored $40$ points, so they did not pass.
From the above, we can see that three people have passed.

Sample Input 2

4 80
79 78 77 76

Sample Output 2

0

There may be cases no one has passed.

Sample Input 3

10 50
31 41 59 26 53 58 97 93 23 84

Sample Output 3

6

---

Solution

涉及算法：枚举

枚举 $N$ 个数，对于每一个数判断是否大于 $L$，如果是，答案加 $1$。

---

Code

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

using namespace std;

typedef pair<int, int> PII;

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

	int N, L;

	cin >> N >> L;

	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 ++)
		if (A[i] >= L)
			Result ++;

	cout << Result << endl;

	return 0;
}

B - Minimize Abs 1

Description

Problem Statement

You are given an integer sequence $A=(A_1,A_2,\dots ,A_N)$ of length $N$ and integers $L$ and $R$ such that $L\le R$.
For each $i=1,2,\dots ,N$, find the integer $X_i$ that satisfies both of the following conditions. Note that the integer to be found is always uniquely determined.
$L\le X_i\le R$.
For every integer $Y$ such that $L\le Y\le R$, it holds that $|X_i-A_i|\le |Y-A_i|$.

Constraints

$1\le N\le 2\times 10^5$
$1\le L\le R\le 10^9$
$1\le A_i\le 10^9$
All input values are integers.

Input

The input is given from Standard Input in the following format:

$N$ $L$ $R$
$A_1$ $\dots$ $A_N$

Output

Print $X_i$ for $i=1,2,\dots ,N$, separated by spaces.

Sample Input 1

5 4 7
3 1 4 9 7

Sample Output 1

4 4 4 7 7

For $i=1$:
$|4-3|=1$
$|5-3|=2$
$|6-3|=3$
$|7-3|=4$
Thus, $X_i=4$.

Sample Input 2

3 10 10
11 10 9

Sample Output 2

10 10 10

---

Solution

涉及算法：贪心

通过贪心的思想，分为 $3$ 中情况：

• $A_i\in [L,R]$：答案为 $A_i$
• $A_i<L$：答案为 $L$
• $A_i>R$：答案为 $R$

---

Code

#include <iostream>
#define int long long

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 2e5 + 10;

int N, L, R;
int A[SIZE];

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

	cin >> N >> L >> R;

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

	for (int i = 1; i <= N; i ++)
		if (A[i] >= L && A[i] <= R)
			cout << A[i] << " ";
		else if (L > A[i])
			cout << L << " ";
		else
			cout << R << " ";

	return 0;
}

C - Minimize Abs 2

Description

Problem Statement

You are given a positive integer $D$.
Find the minimum value of $|x^2+y^2-D|$ for non-negative integers $x$ and $y$.

Constraints

$1\le D\le 2\times 10^{12}$
All input values are integers.

Input

The input is given from Standard Input in the following format:

$D$

Output

Print the answer.

Sample Input 1

21

Sample Output 1

1

For $x=4$ and $y=2$, we have $|x^2+y^2-D|=|16+4-21|=1$.
There are no non-negative integers $x$ and $y$ such that $|x^2+y^2-D|=0$, so the answer is $1$.

Sample Input 2

998244353

Sample Output 2

0

Sample Input 3

264428617

Sample Output 3

32

---

Solution

涉及算法：数学，枚举

通过枚举 $x$，随之 $y$ 也可以确定。

因为 $|x^2+y^2-D|$ 最小，即 $x^2+y^2$ 最接近 $D$。

所以，$y=\sqrt{D-x^2}$，但是为了防止一些精度等问题，作者采取了上下浮动 $1$ 取最小值。即 $y-1$,$y+1$,$y$ 都算出值并取出最小值。

---

Code

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

using namespace std;

typedef pair<int, int> PII;

int D;

int Calc(int x, int y)
{
	return abs(x * x + y * y - D);
}

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

	cin >> D;

	int N = sqrtl(D) + 1, Result = 1e18;
	for (int x = 0; x <= N; x ++)
	{
		int y = sqrtl(abs(D - x * x)), V = min(Calc(x, y), min(Calc(x, y - 1), Calc(x, y + 1)));
		Result = min(Result, V);
	}

	cout << Result << endl;

	return 0;
}

D - Counting Ls

Description

Problem Statement

You are given an $N\times N$ grid. Let $(i,j)$ denote the cell in the $i$-th row from the top and the $j$-th column from the left.
The states of the cells are given by $N$ strings of length $N$, $S_1,S_2,\dots ,S_N$, in the following format:
If the $j$-th character of $S_i$ is o, there is an o written in cell $(i,j)$.
If the $j$-th character of $S_i$ is x, there is an x written in cell $(i,j)$.
Find the number of triples of cells that satisfy all of the following conditions:
The three cells in the triple are distinct.
All three cells have an o written in them.
Exactly two of the cells are in the same row.
Exactly two of the cells are in the same column.
Here, two triples are considered different if and only if some cell is contained in exactly one of the triples.

Constraints

$N$ is an integer between $2$ and $2000$, inclusive.
$S_i$ is a string of length $N$ consisting of o and x.

Input

The input is given from Standard Input in the following format:

$N$
$S_1$
$S_2$
$⋮$
$S_N$

Output

Print the answer as an integer.

Sample Input 1

3
ooo
oxx
xxo

Sample Output 1

4

The following four triples satisfy the conditions:
$(1,1),(1,2),(2,1)$
$(1,1),(1,3),(2,1)$
$(1,1),(1,3),(3,3)$
$(1,2),(1,3),(3,3)$

Sample Input 2

4
oxxx
xoxx
xxox
xxxo

Sample Output 2

0

Sample Input 3

15
xooxxooooxxxoox
oxxoxoxxxoxoxxo
oxxoxoxxxoxoxxx
ooooxooooxxoxxx
oxxoxoxxxoxoxxx
oxxoxoxxxoxoxxo
oxxoxooooxxxoox
xxxxxxxxxxxxxxx
xooxxxooxxxooox
oxxoxoxxoxoxxxo
xxxoxxxxoxoxxoo
xooxxxooxxoxoxo
xxxoxxxxoxooxxo
oxxoxoxxoxoxxxo
xooxxxooxxxooox

Sample Output 3

2960

Solution

涉及算法：前缀和 & 差分，排列组合

其实用不到这么多算法，只是作者做麻烦了（qwq

这道题其实就是找 L 形，所以可以枚举拐点。

那么对于每一个拐点，有多少个 L 行呢？

设正上方 o 的个数为 $u$，左方 o 的个数为 $l$，右方 o 的个数为 $r$，下方 o 的个数为 $d$

则，个数为 $u\cdot l+u\cdot r+d\cdot l+d\cdot r$，即 $(u+d)\cdot (l+r)$

解释：就是每一个上边的 o 都可以和左边，右边任意一个 o 相结合，形成 L 形。下边的同理。

---

Code

#include <iostream>
#define int long long

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 2e3 + 10;

int N;
int Line[SIZE][SIZE], Col[SIZE][SIZE];
char Map[SIZE][SIZE];

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

	cin >> N;

	for (int i = 1; i <= N; i ++)
		for (int j = 1; j <= N; j ++)
		{
			cin >> Map[i][j];
			Line[i][j] = Line[i][j - 1] + (Map[i][j] == 'o');
			Col[i][j] = Col[i - 1][j] + (Map[i][j] == 'o');
		}

	int Result = 0;
	for (int i = 1; i <= N; i ++)
		for (int j = 1; j <= N; j ++)
		{
			if (Map[i][j] == 'x') continue;
			int Up = Col[i - 1][j], Down = Col[N][j] - Col[i][j], Left = Line[i][j - 1], Right = Line[i][N] - Line[i][j];
			Result += Up * (Right + Left) + Down * (Right + Left);
		}

	cout << Result << endl;

	return 0;
}

E - Mex and Update

Description

Problem Statement

You are given a sequence $A=(A_1,A_2,\dots ,A_N)$ of length $N$.
Respond to the following $Q$ queries in the order they are given.
The $k$-th query is given in the following format:

$i_k$ $x_k$

First, change $A_{i_k}$ to $x_k$. This change will carry over to subsequent queries.
Then, print the $\mathrm{mex}$ of $A$.
The $\mathrm{mex}$ of $A$ is the smallest non-negative integer not contained in $A$.

Constraints

All input values are integers.
$1\le N,Q\le 2\times 10^5$
$0\le A_i\le 10^9$
$1\le i_k\le N$
$0\le x_k\le 10^9$

Input

Input is given from Standard Input in the following format:

$N$ $Q$
$A_1$ $A_2$ $\dots$ $A_N$
$i_1$ $x_1$
$i_2$ $x_2$
$⋮$
$i_Q$ $x_Q$

Output

Print $Q$ lines in total.
The $k$-th line should contain the answer to the $k$-th query as an integer.

Sample Input 1

8 5
2 0 2 2 1 1 2 5
4 3
4 4
6 3
8 1000000000
2 1

Sample Output 1

4
3
6
5
0

Initially, the sequence $A$ is $(2,0,2,2,1,1,2,5)$.
This input gives you five queries.
The first query changes $A_4$ to $3$, making $A=(2,0,2,3,1,1,2,5)$.
At this point, the $\mathrm{mex}$ of $A$ is $4$.
The second query changes $A_4$ to $4$, making $A=(2,0,2,4,1,1,2,5)$.
At this point, the $\mathrm{mex}$ of $A$ is $3$.
The third query changes $A_6$ to $3$, making $A=(2,0,2,4,1,3,2,5)$.
At this point, the $\mathrm{mex}$ of $A$ is $6$.
The fourth query changes $A_8$ to $1000000000$, making $A=(2,0,2,4,1,3,2,1000000000)$.
At this point, the $\mathrm{mex}$ of $A$ is $5$.
The fifth query changes $A_2$ to $1$, making $A=(2,1,2,4,1,3,2,1000000000)$.
At this point, the $\mathrm{mex}$ of $A$ is $0$.

---

Solution

涉及算法：权值线段树，二分

大家可能会问了：这题不是 set 吗？怎么成线段树了？

不要问，问就是血的教训

比赛时，看见修改直接想线段树，白写了 $103$ 行（虽然没压行）

这里将讲解一下比赛时的做法，如果大家想练数据结构的话，可以来看一看。

首先，如果这个数的权值大于 $N$，我们不需要进行任何操作，因为对于 $\mathrm{mex}$ 没有任何作用。

证明：最多只有 $N$ 个数，如果这 $N$ 个数为 $0\sim N-1$，也最多输出 $N$，所以大于 $N$ 的数是完全没有作用的，也就是说他以及他之前的数不可能都有。

对于每一个操作，如果权值小于等于 $N$，我们在新权值的位置加 $1$，旧权值的位置减 $1$。

对于查询，二分，对于每一个点判断 $0\sim mid$，线段树中有数位置的和，如果等于 $mid+1$，则说明 $0\sim mid$ 全部都有值，左端点拨到 $mid$，反之右端点拨到 $mid-1$。

所以，线段树应该存储两个信息：

1. 该权值出现的次数
2. 该区间有值的数的个数和

具体详情见代码（码风自我感觉良好

---

Code

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

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 2e5 + 10;

int N, Q;
int A[SIZE];
unordered_map<int, int> Has;
struct Segment
{
	int l, r;
	int Sum, Count;
}Tree[SIZE * 4];

void Pushup(int u)
{
	Tree[u].Sum = Tree[u << 1].Sum + Tree[u << 1 | 1].Sum;
	Tree[u].Count = Tree[u << 1].Count + Tree[u << 1 | 1].Count;
}

void Build(int u, int l, int r)
{
	if (l == r)
	{
		Tree[u] = {l, l, Has[l], min(1ll, Has[l])};
		return;
	}

	Tree[u] = {l, r};
	int mid = l + r >> 1;
	Build(u << 1, l, mid), Build(u << 1 | 1, mid + 1, r);
	Pushup(u);
}

void Modify(int u, int x, int d)
{
	if (Tree[u].l == Tree[u].r && Tree[u].l == x)
	{
		Tree[u].Sum += d;
		Tree[u].Count = (Tree[u].Sum >= 1);
		return;
	}

	int mid = Tree[u].l + Tree[u].r >> 1;
	if (mid >= x) Modify(u << 1, x, d);
	else Modify(u << 1 | 1, x, d);
	Pushup(u);
}

int Query(int u, int l, int r)
{
	if (Tree[u].l >= l && Tree[u].r <= r)
		return Tree[u].Count;

	int mid = Tree[u].l + Tree[u].r >> 1, Result = 0;
	if (mid >= l) Result += Query(u << 1, l, r);
	if (mid < r) Result += Query(u << 1 | 1, l, r);

	return Result;
}

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

	cin >> N >> Q;

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

	Build(1, 0, N);

	while (Q --)
	{
		int I, X;

		cin >> I >> X;

		if (A[I] <= N) Modify(1, A[I], -1);
		if (X <= N) Modify(1, X, 1);
		A[I] = X;

		int l = 0, r = N + 1, Result = 0;
		while (l < r)
		{
			int mid = l + r + 1 >> 1;
			if (Query(1, 0, mid) == mid + 1) l = mid, Result = max(Result, mid + 1);
			else r = mid - 1;
		}

		if (Query(1, 0, 0) == 1) Result = max(1ll, Result);
		cout << Result << endl;
	}

	return 0;
}

F - Minimize Bounding Square

Description

Problem Statement

There are $N$ points labeled $1,2,\dots ,N$ on the $xy$-plane. Point $i$ is located at coordinates $(X_i,Y_i)$.
You can perform the following operation between $0$ and $K$ times, inclusive.
First, choose one of the $N$ points. Let $k$ be the selected point, and assume it is currently at $(x,y)$.
Next, choose and execute one of the following four actions:
Move point $k$ along the $x$-axis by $+1$. The coordinates of point $k$ become $(x+1,y)$.
Move point $k$ along the $x$-axis by $-1$. The coordinates of point $k$ become $(x-1,y)$.
Move point $k$ along the $y$-axis by $+1$. The coordinates of point $k$ become $(x,y+1)$.
Move point $k$ along the $y$-axis by $-1$. The coordinates of point $k$ become $(x,y-1)$.
It is allowed to have multiple points at the same coordinates. Note that the input may already have multiple points at the same coordinates.
After all your operations, draw one square that includes all the $N$ points inside or on the circumference, with each side parallel to the $x$- or $y$-axis.
Find the minimum possible value for the length of a side of this square. This value can be shown to be an integer since all points are always on lattice points.
In particular, if all points can be made to exist at the same coordinates, the answer is considered to be $0$.

Constraints

All input values are integers.
$1\le N\le 2\times 10^5$
$0\le K\le 4\times 10^{14}$
$0\le X_i,Y_i\le 10^9$

Input

Input is given from Standard Input in the following format:

$N$ $K$
$X_1$ $Y_1$
$X_2$ $Y_2$
$\vdots$
$X_N$ $Y_N$

Output

Print the answer as an integer.

Sample Input 1

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

Sample Output 1

3

The figure below illustrates this case with the horizontal $x$-axis and the vertical $y$-axis.

For example, after performing four moves following the arrows in the figure, you can include all points inside or on the circumference of the square shown in the figure with a side length of $3$, and this can be shown to be the minimum value.

Sample Input 2

4 400000000000000
1000000000 1000000000
1000000000 1000000000
1000000000 1000000000
1000000000 1000000000

Sample Output 2

0

All points already exist at the same coordinates from the beginning.

For example, by performing zero operations, all points can be made to exist at the same coordinates, so the answer for this input is $0$.

Sample Input 3

10 998244353
489733278 189351894
861289363 30208889
450668761 133103889
306319121 739571083
409648209 922270934
930832199 304946211
358683490 923133355
369972904 539399938
915030547 735320146
386219602 277971612

Sample Output 3

484373824

---

Solution

涉及算法：二分

本题的精华是将 $x$ 轴，$y$ 轴，分开来计算，即 $x$ 轴上选出一个区间，$y$ 轴上选出一个长度相等的区间。

我们可以二分出正方形的边长，那么只需要枚举左端点即可，这样可推出右端点。

如何计算所有点进入该区间的操作次数呢？

在左端点左边的点的步数为左端点减去左边的点的坐标，在右端点右边的点的步数为右边的点减去右端点。

---

Code

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

using namespace std;

typedef pair<int, int> PII;

const int SIZE = 2e5 + 10;

int N, K;
int X[SIZE], Y[SIZE], Sum[SIZE];

int Calc(int A[], int S)
{
	std::vector<int> B;
	for (int i = 1; i <= N; i ++)
		B.push_back(A[i]), B.push_back(A[i] - S);

	for (int i = 1; i <= N; i ++)
		Sum[i] = Sum[i - 1] + A[i];

	int Result = 1e18;
	for (auto c : B)
	{
		int L = c, R = c + S;
		int Left = lower_bound(A + 1, A + 1 + N, L) - A - 1;
		int Right = upper_bound(A + 1, A + 1 + N, R) - A;
		int CA = 0, CB = 0;
		if (Left > 0)
			CA += L * Left - Sum[Left];
		if (Right <= N)
			CB += Sum[N] - Sum[Right - 1] - R * (N - Right + 1);
		Result = min(Result, CA + CB);
	}

	return Result;
}

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

	cin >> N >> K;

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

	sort(X + 1, X + 1 + N);
	sort(Y + 1, Y + 1 + N);

	int l = 0, r = 2e9;
	while (l < r)
	{
		int mid = l + r >> 1;
		if (Calc(X, mid) + Calc(Y, mid) <= K)
			r = mid;
		else
			l = mid + 1;
	}

	cout << r << endl;

	return 0;
}