Equal Reversal
Contest: Codeforces Round 803 (Div. 2)
Difficulty rating: 2800
Tags: constructive algorithms, graphs, implementation, math

There is an array $$$a$$$ of length $$$n$$$. You may perform the following operation on it:

- Choose two indices $$$l$$$ and $$$r$$$ where $$$1 \le l \le r \le n$$$ and $$$a_l = a_r$$$. Then, reverse the subsegment from the $$$l$$$-th to the $$$r$$$-th element, i. e. set $$$[a_l, a_{l + 1}, \ldots, a_{r - 1}, a_r]$$$ to $$$[a_r, a_{r-1}, \ldots, a_{l+1}, a_l]$$$.

You are also given another array $$$b$$$ of length $$$n$$$ which is a permutation of $$$a$$$. Find a sequence of at most $$$n^2$$$ operations that transforms array $$$a$$$ into $$$b$$$, or report that no such sequence exists.

Input format:
Each test contains multiple test cases. The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 100$$$) — the number of test cases. The description of the test cases follows.

The first line of each test case contains an integer $$$n$$$ ($$$1 \le n \le 500$$$) — the length of array $$$a$$$ and $$$b$$$.

The second line of each test case contains $$$n$$$ integers $$$a_1, a_2, \ldots, a_n$$$ ($$$1 \le a_i \le n$$$) — elements of the array $$$a$$$.

The third line of each test case contains $$$n$$$ integers $$$b_1, b_2, \ldots, b_n$$$ ($$$1 \le b_i \le n$$$) — elements of the array $$$b$$$.

It is guaranteed that $$$b$$$ is a permutation of $$$a$$$.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$500$$$.

Output format:
For each test case, output "NO" (without quotes) if it is impossible to turn $$$a$$$ into $$$b$$$ using at most $$$n^2$$$ operations.

Otherwise, output "YES" (without quotes). Then output an integer $$$k$$$ ($$$0 \leq k \leq n^2$$$) denoting the number of operations you will perform. Note that you don't have to minimize the number of operations.

Afterwards, output $$$k$$$ lines. The $$$i$$$-th line should contain two integers $$$l_i$$$ and $$$r_i$$$ ($$$1 \leq l_i \leq r_i \leq n$$$) — the left and right indices for the $$$i$$$-th operation.

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

If there are multiple possible sequences of operations, you may output any of them.

Constraints:
Time limit: 1.0 s
Memory limit: 256.0 MB

Note:
In the first test case, we can perform the following operations: $$$$$$[1,2,4,3,1,2,1,1] \xrightarrow[l=5,\,r=8]{} [1,2,4,3,1,1,2,1] \xrightarrow[l=1,\,r=6]{} [1,1,3,4,2,1,2,1].$$$$$$

In the second test case, we can perform the following operations: $$$$$$[1,2,3,1,3,2,3] \xrightarrow[l=1,\,r=4]{} [1,3,2,1,3,2,3] \xrightarrow[l=3,\,r=6]{} [1,3,2,3,1,2,3].$$$$$$

It can be proven that it is impossible to turn $$$a$$$ into $$$b$$$ in the third and fourth test cases.

Example input:
5
8
1 2 4 3 1 2 1 1
1 1 3 4 2 1 2 1
7
1 2 3 1 3 2 3
1 3 2 3 1 2 3
3
1 1 2
1 2 1
2
1 2
2 1
1
1
1

Example output:
YES
2
5 8
1 6
YES
2
1 4
3 6
NO
NO
YES
0

Editorial:
Consider the following invariants of the array:
• $$$a_1$$$ and $$$a_n$$$ don't change as a result of the operations.
• The set of unordered pairs of adjacent elements doesn't change as a result of the operations. In other words, if you build a graph $$$\mathcal{G}$$$ whose vertices are labelled $$$1$$$ to $$$n$$$, and make an edge connecting $$$a_i$$$ and $$$a_{i+1}$$$ for all $$$1 \leq i < n$$$, the graph does not change after operations. This is because the operation can be seen as reversing the order we traverse a cycle in $$$\mathcal{G}$$$, which doesn't change the undirected graph.
The first element of $$$a$$$ already has to match. Suppose the second element does not match; that is, $$$a_1 = b_1$$$ but $$$a_2 \neq b_2$$$. Then there has to be some other copy of $$$b_1$$$ later in $$$a$$$ next to the element in $$$a$$$ equal to $$$b_2$$$, by the graph condition mentioned above. If the copy of $$$b_1$$$ appears after the element equal to $$$b_2$$$, we can reverse the subarray whose endpoints are the two copies of $$$b_1$$$. Otherwise, it can be shown that there must exist some subarray with equal endpoints that contains $$$b_1$$$ followed by $$$b_2$$$, so we can reverse it.
This takes $$$2n$$$ operations, but it requires $$$\mathcal{O}(n^2)$$$ time to construct. So the overall complexity is $$$\mathcal{O}(n^3)$$$.