A. Shuffle Party

A. Shuffle Party

                                          A. Shuffle Party
                                   time limit per test: 1 second
                               memory limit per test: 256 megabytes
                                       input: standard input
                                       output: standard output

You are given an array $a_1,a_2,\dots ,a_n$. Initially, $a_i=i$ for each $1\le i\le n$.
The operation $\text{swap}(k)$ for an integer $k\ge 2$ is defined as follows:

• Let $d$ be the largest divisor${}^{†}$ of $k$ which is not equal to $k$ itself. Then swap the elements $a_d$ and $a_k$.
  Suppose you perform $\text{swap}(i)$ for each $i=2,3,\dots ,n$ in this exact order. Find the position of $1$ in the resulting array. In other words, find such $j$ that $a_j=1$ after performing these operations.
  ${}^{†}$ An integer $x$ is a divisor of $y$ if there exists an integer $z$ such that $y=x\cdot z$.

Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^4$). The description of the test cases follows.
The only line of each test case contains one integer $n$ ($1\le n\le 10^9$) — the length of the array $a$.

Output

For each test case, output the position of $1$ in the resulting array.

Input
4
1
4
5
120240229

Output
1
4
4
67108864

Note

In the first test case, the array is $[1]$ and there are no operations performed.

In the second test case, $a$ changes as follows:

• Initially, $a$ is $[1,2,3,4]$.
• After performing $\text{swap}(2)$, $a$ changes to $[\underline{2},\underline{1},3,4]$ (the elements being swapped are underlined).
• After performing $\text{swap}(3)$, $a$ changes to $[\underline{3},1,\underline{2},4]$.
• After performing $\text{swap}(4)$, $a$ changes to $[3,\underline{4},2,\underline{1}]$.

Finally, the element $1$ lies on index $4$ (that is, $a_4=1$). Thus, the answer is $4$.

1、模拟过程

例如，数组的长度是 $5$，由题可知，$d$是$k$的最大除数，但是$d$不等于$k$，则如果$k\%d=0$，那么就将下标为$d$和$k$的元素进行交换，模拟过程如下：

$i$	1	2	3	4	5
$a[i]$	1	2	3	4	5

$$\Downarrow$$

$i$	1	2	3	4	5
$a[i]$	2	1	3	4	5

$$\Downarrow$$

$i$	1	2	3	4	5
$a[i]$	3	1	2	4	5

$$\Downarrow$$

$i$	1	2	3	4	5
$a[i]$	3	4	2	1	5

$$\Downarrow$$

$i$	1	2	3	4	5
$a[i]$	5	4	2	1	3

2、代码

#include<iostream>
using namespace std;
const int N = 1e4 + 10;
int t, n;
int main() {
	scanf("%d", &t);
	while (t--) {
		int p = 1;
		scanf("%d", &n);
		while (2 * p <= n) {
			p <<= 1;
		}
		printf("%d\n", p);
	}
	return 0;
}

B. Binary Path

B. Binary Path

                                         B. Binary Path
                                  time limit per test: 1 second
                               memory limit per test: 256 megabytes
                                     input: standard input
                                     output: standard output

You are given a $2\times n$ grid filled with zeros and ones. Let the number at the intersection of the $i$-th row and the $j$-th column be $a_{ij}$.

There is a grasshopper at the top-left cell $(1,1)$ that can only jump one cell right or downwards. It wants to reach the bottom-right cell $(2,n)$. Consider the binary string of length $n+1$ consisting of numbers written in cells of the path without changing their order.

Your goal is to:

1. Find the lexicographically smallest${}^{†}$ string you can attain by choosing any available path;
2. Find the number of paths that yield this lexicographically smallest string.

${}^{†}$ If two strings $s$ and $t$ have the same length, then $s$ is lexicographically smaller than $t$ if and only if in the first position where $s$ and $t$ differ, the string $s$ has a smaller element than the corresponding element in $t$.

Input

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1\le t\le 10^4$). The description of the test cases follows.

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

The second line of each test case contains a binary string $a_{11}{a}_{12}\dots a_{1n}$ ($a_{1i}$ is either $0$ or $1$).

The third line of each test case contains a binary string $a_{21}{a}_{22}\dots a_{2n}$ ($a_{2i}$ is either $0$ or $1$).

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

Output

For each test case, output two lines:

1. The lexicographically smallest string you can attain by choosing any available path;
2. The number of paths that yield this string.

Input
3
2
00
00
4
1101
1100
8
00100111
11101101

Output
000
2
11000
1
001001101
4

Note

In the first test case, the lexicographically smallest string is $000$. There are two paths that yield this string:

In the second test case, the lexicographically smallest string is $11000$. There is only one path that yields this string:

1、过程模拟

由题可知，蚂蚱只能向右或者是向下移动，并且使得二进制数的值是最小的路径，路径条数不止一条，但二进制数值是一样的。
我们可以先从第一行的最后一列和第二行的倒数第二列进行比较，设 $max\_down=n$，$min\_down=1$，如果第一行的最后一列是 $1$，第二行的倒数第二列是 $0$，则将第一行原本的长度减一，即 $max\_down=n-1$。
再从第二行的第一列和第一行的第二列进行比较，设 $max\_down=n$，$min\_down=1$，如果第二行的第一列是 $1$，第一行的第二列是 $0$，则$min\_down=1+1$，根据以上步骤以此类推。

2、代码

#include<iostream>
#include<algorithm>
using namespace std;
#define orz 0
const int N = 2e5 + 10;
int t, n;
char a[4][N];
int main() {
	scanf("%d", &t);
	while (t--) {
		scanf("%d", &n);
		for (int i = 1; i <= 2; i++) {
			scanf("\n");
			for (int j = 1; j <= n; j++) {
				scanf("%c", &a[i][j]);
			}
		}
		int max_down = n, min_down = 1;
		for (int i = n; i >= 2; i--) {
			if (a[1][i] == '1' && a[2][i - 1] == '0') {
				max_down = i - 1;
			}
		}
		for (int i = 1; i < max_down; i++) {
			if (a[1][i + 1] == '0' && a[2][i] == '1') {
				min_down = i + 1;
			}
		}
		for (int i = 1; i <= max_down; i++) {
			printf("%c", a[1][i]);
		}
		for (int i = max_down; i <= n; i++) {
			printf("%c", a[2][i]);
		}
		puts("");
		printf("%d\n", max_down - min_down + 1);
	}
	return orz;
}