C - Find it!

1. Description

Problem Statement

There is a directed graph with $N$ vertices and $N$ edges.

The $i$-th edge goes from vertex $i$ to vertex $A_i$. (The constraints guarantee that $i\ne A_i$.)

Find a directed cycle without the same vertex appearing multiple times.

It can be shown that a solution exists under the constraints of this problem.

Notes

The sequence of vertices B = ($B_1,B_2,\dots ,B_M$) is called a directed cycle when all of the following conditions are satisfied:
$\bullet$ $M\ge 2$
$\bullet$ The edge from vertex $B_i$ to vertex $B_{i+1}$ exists. ($1\le i\le M-1$)
$\bullet$ The edge from vertex $B_M$ to vertex $B_1$ exists.
$\bullet$ If $i\ne j$ , then $B_i\ne B_j$ .

Constraints

All input values are integers.
$2\le N\le 2\times 10^5$
$1\le A_i\le N$
$A_i\ne i$

Input

The input is given from Standard Input in the following format:
$N$
$A_1$ $A_2$ $\dots$ $A_N$

Output

Print a solution in the following format:
$M$
$B_1$ $B_2$ $\dots$ $B_M$

$M$ is the number of vertices, and $B_i$ is the $i$-th vertex in the directed cycle.
The following conditions must be satisfied:
$2\le M$
$B_{i+1}=A_{B_i}$ ( $1\le i\le M-1$ )
$B_1=A_{B_M}$
$B_i\ne B_j$ ( $i\ne j$ )

If multiple solutions exist, any of them will be accepted.

Sample Input 1

7
6 7 2 1 3 4 5

Sample Output 1

4
7 5 3 2

$7\to 5\to 3\to 2\to 7$ is indeed a directed cycle.
Here is the graph corresponding to this input:

Here are other acceptable outputs:
4
2 7 5 3

3
4 1 6

Note that the graph may not be connected.

Sample Input 2

2
2 1

Sample Output 2

2
1 2
This case contains both of the edges $1\to 2$ and $2\to 1$.
In this case, $1\to 2\to 1$ is indeed a directed cycle.
Here is the graph corresponding to this input, where $1\leftrightarrow 2$ represents the existence of both $1\to 2$ and $2\to 1$:

Sample Input 3

8
3 7 4 7 3 3 8 2

Sample Output 3

3
2 7 8
Here is the graph corresponding to this input:

2. Solution

3. Code

#include <iostream>
#include <vector>
#include <cstring>
#include <unordered_map>

using namespace std;

const int N = 2e5 + 10;

int n;
int a[N];
int h[N], e[N], idx, ne[N], st[N];
vector<int> pass;
int res;
unordered_map<int, int> pos;
int b[N];
bool flg;

void add(int a, int b)
{
	e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void dfs(int u)
{
	if (st[u] || flg) return;
	st[u] = 1;
	
	for (int i = h[u]; ~i; i = ne[i])
	{
		if (st[e[i]] == 1)
		{
			res = e[i];
			flg = 1;
			return;
		}
		else if (st[e[i]] != 2)
		{
			pass.push_back(e[i]);
			dfs(e[i]);
			if (flg) return;
			pass.pop_back();
		}
	}
	
	st[u] = 2;
}

int main()
{
	cin >> n;
	
	for (int i = 1; i <= n; i ++)
		cin >> a[i], add(i, a[i]), pos[a[i]] = i;
		
	for (int i = 1; i <= n; i ++)
		if (!flg)
			dfs(i);
		
	b[1] = res;
	int k = n;
	for (int i = 1; i <= n; i ++)
	{
		b[i + 1] = a[b[i]];
		if (b[i + 1] == b[1])
		{
			k = i;
			break;
		}
	}	
	
	cout << k << endl;
	for (int i = 1; i <= k; i ++)
		cout << b[i] << " ";

	return 0;
}

---

D - Grid Ice Floor

1. Description

Problem Statement

There is an $N\times M$ grid and a player standing on it.

Let $(i,j)$ denote the square at the $i$-th row from the top and $j$-th column from the left of this grid.

Each square of this grid is ice or rock, which is represented by $N$ strings $S_1,S_2,\dots ,S_N$ of length $M$ as follows:
if the $j$-th character of $S_i$ is ., square $(i,j)$ is ice;
if the $j$-th character of $S_i$ is #, square $(i,j)$ is rock.
The outer periphery of this grid (all squares in the $1$-st row, $N$-th row, $1$-st column, $M$-th column) is rock.
Initially, the player rests on the square $(2,2)$, which is ice.

The player can make the following move zero or more times.
First, specify the direction of movement: up, down, left, or right.
Then, keep moving in that direction until the player bumps against a rock. Formally, keep doing the following:
if the next square in the direction of movement is ice, go to that square and keep moving;
if the next square in the direction of movement is rock, stay in the current square and stop moving.
Find the number of ice squares the player can touch (pass or rest on).

Constraints

$3\le N,M\le 200$
$S_i$ is a string of length $M$ consisting of # and ..
Square $(i,j)$ is rock if $i=1$, $i=N$, $j=1$, or $j=M$.
Square $(2,2)$ is ice.

Input

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

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

Output

Print the answer as an integer.

Sample Input 1

6 6
######
#....#
#.#..#
#..#.#
#....#
######

Sample Output 1

12

For instance, the player can rest on $(5,5)$ by moving as follows:
$(2,2)\to (5,2)\to (5,5)$.
The player can pass $(2,4)$ by moving as follows:
$(2,2)\to (2,5)$, passing $(2,4)$ in the process.
The player cannot pass or rest on $(3,4)$.

Sample Input 2

21 25
#########################
#..............###...####
#..............#..#...###
#........###...#...#...##
#........#..#..#........#
#...##...#..#..#...#....#
#..#..#..###...#..#.....#
#..#..#..#..#..###......#
#..####..#..#...........#
#..#..#..###............#
#..#..#.................#
#........##.............#
#.......#..#............#
#..........#....#.......#
#........###...##....#..#
#..........#..#.#...##..#
#.......#..#....#..#.#..#
##.......##.....#....#..#
###.............#....#..#
####.................#..#
#########################

Sample Output 2

215

2. Solution

3. Code

#include <bits/stdc++.h>
#define x first
#define y second
#define int long long

using namespace std;

const int N = 2e2 + 10;
typedef pair<int, int> PII;

int h, w;
char s[N][N];
bool st[N][N], vis[N][N];
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};

void bfs(int sx, int sy)
{
	queue<PII> q;
	
	q.push({sx, sy});
	
	while (q.size())
	{
		auto t = q.front();
		q.pop();
		
		for (int i = 0; i < 4 ;i ++)
		{
			int xx = t.x, yy = t.y;
			while (s[xx][yy] == '.')
				st[xx][yy] = 1, xx += dx[i], yy += dy[i];
			xx -= dx[i], yy -= dy[i];
			
			if (!vis[xx][yy])
				vis[xx][yy] = 1, q.push({xx, yy});
		}
	}
}

signed main()
{
	cin >> h >> w;
	
	for (int i = 1; i <= h; i ++)
		for (int j = 1; j <= w; j ++)
			cin >> s[i][j];
			
	bfs(2, 2);
	
	int res = 0;
	for (int i = 1; i <= h; i ++)
		for (int j = 1; j <= w; j ++)
			res += st[i][j];
			
	cout << res << endl;
			
	return 0;
}

---

E - Defect-free Squares

1. Description

Problem Statement

There is a grid with $H$ rows and $W$ columns. Let $(i,j)$ denote the square at the $i$-th row from the top and $j$-th column from the left of the grid.

Each square of the grid is holed or not. There are exactly $N$ holed squares: $(a_1,b_1),(a_2,b_2),\dots ,(a_N,b_N)$.
When the triple of positive integers $(i,j,n)$ satisfies the following condition, the square region whose top-left corner is $(i,j)$ and whose bottom-right corner is $(i+n-1,j+n-1)$ is called a holeless square.
$i+n-1\le H$.
$j+n-1\le W$.
For every pair of non-negative integers $(k,l)$ such that $0\le k\le n-1,0\le l\le n-1$, square $(i+k,j+l)$ is not holed.
How many holeless squares are in the grid?

Constraints

$1\le H,W\le 3000$
$0\le N\le \min (H\times W,10^5)$
$1\le a_i\le H$
$1\le b_i\le W$
All $(a_i,b_i)$ are pairwise different.
All input values are integers.

Input

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

$H$ $W$ $N$
$a_1$ $b_1$
$a_2$ $b_2$
$⋮$
$a_N$ $b_N$

Output

Print the number of holeless squares.

Sample Input 1

2 3 1
2 3

Sample Output 1

6

There are six holeless squares, listed below. For the first five, $n=1$, and the top-left and bottom-right corners are the same square.
The square region whose top-left and bottom-right corners are $(1,1)$.
The square region whose top-left and bottom-right corners are $(1,2)$.
The square region whose top-left and bottom-right corners are $(1,3)$.
The square region whose top-left and bottom-right corners are $(2,1)$.
The square region whose top-left and bottom-right corners are $(2,2)$.
The square region whose top-left corner is $(1,1)$ and whose bottom-right corner is $(2,2)$.

Sample Input 2

3 2 6
1 1
1 2
2 1
2 2
3 1
3 2

Sample Output 2

0

There may be no holeless square.

Sample Input 3

1 1 0

Sample Output 3

1

The whole grid may be a holeless square.

Sample Input 4

3000 3000 0

Sample Output 4

9004500500

2. Solution

此题可以用两个思路来做，一是二分+前缀和，二是dp，具体见视频。

3. Code

思路1：（二分+前缀和）

#include <bits/stdc++.h>
#define int long long

using namespace std;

const int N = 3e3 + 10;

int h, w, k;
int a, b;
bool mp[N][N];
int sum[N][N];

bool check(int a, int b, int c)
{
	int tmp = sum[a + c - 1][b + c - 1] - sum[a + c - 1][b - 1] - sum[a - 1][b + c - 1] + sum[a - 1][b - 1];
	return (tmp == 0);
}

signed main()
{
	cin >> h >> w >> k;
	
	for (int i = 1; i <= k; i ++)
		cin >> a >> b, mp[a][b] = 1;
		
	for (int i = 1; i <= h; i ++)
		for (int j = 1; j <= w; j ++)
			sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mp[i][j];
			
	int res = 0;
	for (int i = 1; i <= h; i ++)
		for (int j = 1; j <= w; j ++)
		{
			int l = 0, r = min(h - i + 1, w - j + 1);
			while (l < r)
			{
				int mid = l + r + 1 >> 1;
				if (check(i, j, mid)) l = mid;
				else r = mid - 1;
			}
			
			res += l;
		}
		
	cout << res << endl;
	
	return 0;
}

思路2：（Dp）

#include <iostream>
#define int long long

using namespace std;

const int N = 3e3 + 10;

int n, m, k;
int a, b;
int mp[N][N], dp[N][N];

signed main()
{
	cin >> n >> m >> k;
	
	for (int i = 1; i <= k; i ++)
			cin >> a >> b, mp[a][b] = 1;
			
	int res =0 ;
	for (int i = 1; i <= n; i ++)
		for (int j = 1; j <= m; j ++)
		{
			dp[i][j] = min(dp[i - 1][j], min(dp[i][j - 1], dp[i - 1][j - 1])) + 1;
			if (mp[i][j])
				dp[i][j] = 0;
			res += dp[i][j];
		}
		
	cout << res << endl;
	
	return 0;
}

最后祝大家早日