算法刷题day54：搜索（一）

引言

针对于蓝桥杯，搜索问题还是非常之重要的，在省赛前深知暴搜的重要性，所以提前先把提高课的搜索一章给看了，结果省赛时用到的算法很少，几乎是没有，反而是刚学一两个星期的暴搜给了我很大的作用，全部题目几乎都用的是暴搜，所以对于 $O I$ 赛制来说，暴搜的技巧还是很重要的，其实到了国赛也是很重要，听说国赛题都很难，而且有的题都是假题，所以说对于这种题，暴搜就显得更重要了，听说全打暴力就能国三，再对个一两道题目说不定就能国二，其实暴搜大部分样例跟全做出来没啥区别，只要你剪枝剪的好，就能多对几个样例，还是要多练，加油！

一、池塘计数

标签：BFS、Flood Fill

思路：其实就是一个找连通块的题目，只不过是一个八连通的，把 $BFS$ 里的循环和方向变为对应的八个方向即可。具体的做法就是，遍历每一个格子，如果该格子没有被访问过，并且是一个池塘，就用 $BFS$ 把这个池塘全部访问，然后结果加一，最后输出结果。

题目描述：

农夫约翰有一片 N∗M 的矩形土地。

最近，由于降雨的原因，部分土地被水淹没了。

现在用一个字符矩阵来表示他的土地。

每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。

现在，约翰想知道他的土地中形成了多少片池塘。

每组相连的积水单元格集合可以看作是一片池塘。

每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。

请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。

输入格式
第一行包含两个整数 N 和 M。

接下来 N 行，每行包含 M 个字符，字符为”W”或”.”，用以表示矩形土地的积水状况，字符之间没有空格。

输出格式
输出一个整数，表示池塘数目。

数据范围
1≤N,M≤1000
输入样例：
10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.
输出样例：
3

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
char g[N][N];
bool st[N][N];

int dir[8][2] = {-1,-1, -1,0, -1,1, 0,-1, 0,1, 1,-1, 1,0, 1,1};

void bfs(PII S)
{
	st[S.x][S.y] = true;
	
	queue<PII> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		
		for(int i = 0; i < 8; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= m) continue;
			if(st[x][y] || g[x][y] == '.') continue;
			
			st[x][y] = true;
			q.push({x,y});
		}
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i) cin >> g[i];
	
	int res = 0;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < m; ++j)
		{
			if(!st[i][j] && g[i][j] == 'W')
			{
				res++;
				bfs({i,j});
			}
		}
	}
	
	cout << res << endl;
	
	return 0;
}

二、城堡问题

标签：BFS

思路：这道题要求的是连通块的个数，以及连通块中最大的那个。不一样的是，该题的限制变成了每一个房间都会有墙，也就是说能不能向某一个方向移动就看该方向是否有墙，一般这种拿数字代表墙的都是二进制位来表示的，只要把对应方向和该二进制位对应起来，拿位运算就知道该方向是否有墙，然后就是正常操作了，每找一个点就给该连通块数加一，返回总数即可。

题目描述：

    1   2   3   4   5   6   7  
   #############################
 1 #   |   #   |   #   |   |   #
   #####---#####---#---#####---#
 2 #   #   |   #   #   #   #   #
   #---#####---#####---#####---#
 3 #   |   |   #   #   #   #   #
   #---#########---#####---#---#
 4 #   #   |   |   |   |   #   #
   #############################
           (图 1)

   #  = Wall   
   |  = No wall
   -  = No wall

   方向：上北下南左西右东。
图1是一个城堡的地形图。

请你编写一个程序，计算城堡一共有多少房间，最大的房间有多大。

城堡被分割成 m∗n个方格区域，每个方格区域可以有0~4面墙。

注意：墙体厚度忽略不计。

输入格式
第一行包含两个整数 m 和 n，分别表示城堡南北方向的长度和东西方向的长度。

接下来 m 行，每行包含 n 个整数，每个整数都表示平面图对应位置的方块的墙的特征。

每个方块中墙的特征由数字 P 来描述，我们用1表示西墙，2表示北墙，4表示东墙，8表示南墙，P 为该方块包含墙的数字之和。

例如，如果一个方块的 P 为3，则 3 = 1 + 2，该方块包含西墙和北墙。

城堡的内墙被计算两次，方块(1,1)的南墙同时也是方块(2,1)的北墙。

输入的数据保证城堡至少有两个房间。

输出格式
共两行，第一行输出房间总数，第二行输出最大房间的面积（方块数）。

数据范围
1≤m,n≤50,0≤P≤15
输入样例：
4 7 
11 6 11 6 3 10 6 
7 9 6 13 5 15 5 
1 10 12 7 13 7 5 
13 11 10 8 10 12 13 
输出样例：
5
9

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 55, M = N, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
bool st[N][N];

int dir[4][2] = {0,-1, -1,0, 0,1, 1,0};  // 对应方向 

int bfs(PII S)  // 找出每个连通块内的块数
{
	st[S.x][S.y] = true;
	
	int res = 1;
	queue<PII> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		
		for(int i = 0; i < 4; ++i)
		{
			// 注意这里是从 t 走的
			if(g[t.x][t.y] >> i & 1) continue;  // 刚好用与运算与之对应方向
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= m) continue;
			if(st[x][y]) continue;
			
			res++;
			st[x][y] = true;
			q.push({x,y}); 
		}	
	}
	return res;	
} 

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;  // 不要被变量名所骗，要看具体含义
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < m; ++j)
		{
			cin >> g[i][j];
		}
	}
	
	int sum = 0, maxv = 0;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < m; ++j)
		{
			if(!st[i][j])
			{
				int t = bfs({i,j});
				sum++;
				maxv = max(maxv, t);
			}
		}
	}
	
	cout << sum << endl << maxv << endl;
	
	return 0;
}

三、山峰和山谷

标签：BFS、Flood Fill

思路：这道题问山峰和山谷的数量，其实就是遍历每一个连通块（高度相同），然后遍历的同时，看看周围有没有比它更高的或者更低的，如果没有比他高的那就是山峰，如果没有比它低的，那就是山谷，如果两个都没有那就都是，刚好也满足题目的要求。有一个细节，就是判断的是周围，所以只要不越界就都要判断一下，所以不必先判断是否能走，应最后判断。

题目描述：

FGD小朋友特别喜欢爬山，在爬山的时候他就在研究山峰和山谷。

为了能够对旅程有一个安排，他想知道山峰和山谷的数量。

给定一个地图，为FGD想要旅行的区域，地图被分为 n×n 的网格，每个格子 (i,j) 的高度 w(i,j) 是给定的。

若两个格子有公共顶点，那么它们就是相邻的格子，如与 (i,j) 相邻的格子有(i−1,j−1),(i−1,j),(i−1,j+1),(i,j−1),(i,j+1)，(i+1,j−1)
,(i+1,j),(i+1,j+1)。

我们定义一个格子的集合 S 为山峰（山谷）当且仅当：

S 的所有格子都有相同的高度。S 的所有格子都连通。对于 s 属于 S，与 s 相邻的 s′ 不属于 S，都有 ws>ws′（山峰），或者 ws<ws′（山谷）。

如果周围不存在相邻区域，则同时将其视为山峰和山谷。

你的任务是，对于给定的地图，求出山峰和山谷的数量，如果所有格子都有相同的高度，那么整个地图即是山峰，又是山谷。

输入格式
第一行包含一个正整数 n，表示地图的大小。

接下来一个 n×n 的矩阵，表示地图上每个格子的高度 w。

输出格式
共一行，包含两个整数，表示山峰和山谷的数量。

数据范围
1≤n≤1000,0≤w≤109
输入样例1：
5
8 8 8 7 7
7 7 8 8 7
7 7 7 7 7
7 8 8 7 8
7 8 8 8 8
输出样例1：
2 1
输入样例2：
5
5 7 8 3 1
5 5 7 6 6
6 6 6 2 8
5 7 2 5 8
7 1 0 1 7
输出样例2：
3 3

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
bool st[N][N];
int high, low;

int dir[8][2] = {-1,-1, -1,0, -1,1, 0,-1, 0,1, 1,-1, 1,0, 1,1};

void bfs(PII S)
{
	st[S.x][S.y] = true;
	
	bool has_higher = false, has_lower = false;
	queue<PII> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		
		for(int i = 0; i < 8; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= n) continue;  // 先判断是否越界
			
			if(g[x][y] > g[t.x][t.y]) has_higher = true;  // 判断周围
			if(g[x][y] < g[t.x][t.y]) has_lower = true;
			
			if(st[x][y] || g[x][y] != g[t.x][t.y]) continue;  // 判断是否为连通块
			
			st[x][y] = true;
			q.push({x,y});
		}
	}
	
	if(!has_higher) high++;  // 没有比它高的
	if(!has_lower) low++;  // 没有比他低的 
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < n; ++j)
		{
			cin >> g[i][j];
		}
	}
	
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < n; ++j)
		{
			if(!st[i][j])
			{
				bfs({i,j});
			}
		}
	}
	
	cout << high << " " << low << endl;
	
	return 0;
}

四、迷宫问题

标签：BFS

思路：这道题问的是一个最短的路径，其实针对于 $BFS$ 来说第一次走过的点，就是该点的最短路径，我们只要在遍历的时候，把要更新的点的前驱记下来即可。因为路径是从起点开始，我们可以直接从后向前遍历，这样在推导的时候就可以顺便打印了。

题目描述：

给定一个 n×n 的二维数组，如下所示：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角
的最短路线。

数据保证至少存在一条从左上角走到右下角的路径。

输入格式
第一行包含整数 n。

接下来 n 行，每行包含 n 个整数 0 或 1，表示迷宫。

输出格式
输出从左上角到右下角的最短路线，如果答案不唯一，输出任意一条路径均可。

按顺序，每行输出一个路径中经过的单元格的坐标，左上角坐标为 (0,0)，右下角坐标为 (n−1,n−1)。

数据范围
0≤n≤1000
输入样例：
5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例：
0 0
1 0
2 0
2 1
2 2
2 3
2 4
3 4
4 4

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
bool st[N][N];
PII pre[N][N]; 

int dir[4][2] = {0,1,0,-1,1,0,-1,0};

void bfs()
{
	st[n-1][n-1] = true;
	
	queue<PII> q; q.push({n-1,n-1});
	while(q.size())
	{
		auto t = q.front(); q.pop();
		if(t.x == 0 && t.y == 0) return;
		
		for(int i = 0; i < 4; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= n) continue;
			if(st[x][y] || g[x][y] == 1) continue;
			
			st[x][y] = true;
			pre[x][y] = {t.x,t.y};
			q.push({x,y});
		}
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n;
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < n; ++j)
		{
			cin >> g[i][j];
		}
	}
	
	bfs();
	
	PII start = {0,0}, end = {n-1,n-1};
	while(start != end)
	{
		cout << start.x << " " << start.y << endl;
		start = pre[start.x][start.y];
	}
	cout << end.x << " " << end.y << endl;
	
	return 0;
}

五、武士风度的牛

标签：搜索、广度优先搜索、BFS

思路：这道题首先要看清楚行列，不一定是按顺序给你的，所以要小心，然后就是只不过搜索的时候把方式变了，其实本质上还是行列的一个变化而已，然后就是正常的求最短路。

最短路注意要点： 1. 输入的行列顺序 2. 起始点有时就是障碍 3. 起点有时是终点 4. 终点的符号跟正常的符号不一样

题目描述：

农民 John 有很多牛，他想交易其中一头被 Don 称为 The Knight 的牛。

这头牛有一个独一无二的超能力，在农场里像 Knight 一样地跳（就是我们熟悉的象棋中马的走法）。

虽然这头神奇的牛不能跳到树上和石头上，但是它可以在牧场上随意跳，我们把牧场用一个 x，y 的坐标图来表示。

这头神奇的牛像其它牛一样喜欢吃草，给你一张地图，上面标注了 The Knight 的开始位置，树、灌木、石头以及其它障碍的位置，
除此之外还有一捆草。

现在你的任务是，确定 The Knight 要想吃到草，至少需要跳多少次。

The Knight 的位置用 K 来标记，障碍的位置用 * 来标记，草的位置用 H 来标记。

这里有一个地图的例子：

             11 | . . . . . . . . . .
             10 | . . . . * . . . . . 
              9 | . . . . . . . . . . 
              8 | . . . * . * . . . . 
              7 | . . . . . . . * . . 
              6 | . . * . . * . . . H 
              5 | * . . . . . . . . . 
              4 | . . . * . . . * . . 
              3 | . K . . . . . . . . 
              2 | . . . * . . . . . * 
              1 | . . * . . . . * . . 
              0 ----------------------
                                    1 
                0 1 2 3 4 5 6 7 8 9 0 
The Knight 可以按照下图中的 A,B,C,D… 这条路径用 5 次跳到草的地方（有可能其它路线的长度也是 5）：

             11 | . . . . . . . . . .
             10 | . . . . * . . . . .
              9 | . . . . . . . . . .
              8 | . . . * . * . . . .
              7 | . . . . . . . * . .
              6 | . . * . . * . . . F<
              5 | * . B . . . . . . .
              4 | . . . * C . . * E .
              3 | .>A . . . . D . . .
              2 | . . . * . . . . . *
              1 | . . * . . . . * . .
              0 ----------------------
                                    1
                0 1 2 3 4 5 6 7 8 9 0
注意： 数据保证一定有解。

输入格式
第 1 行： 两个数，表示农场的列数 C 和行数 R。

第 2..R+1 行: 每行一个由 C 个字符组成的字符串，共同描绘出牧场地图。

输出格式
一个整数，表示跳跃的最小次数。

数据范围
1≤R,C≤150
输入样例：
10 11
..........
....*.....
..........
...*.*....
.......*..
..*..*...H
*.........
...*...*..
.K........
...*.....*
..*....*..
输出样例：
5

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 155, M = N, INF = 0x3f3f3f3f;

int n, m;
char g[N][N];
int dist[N][N];
PII S, E;

int dir[8][2] = {-2,-1, -2,1, -1,-2, -1,2, 1,-2, 1,2, 2,-1, 2,1};

int bfs()
{
	if(g[S.x][S.y] == '*' || g[E.x][E.y] == '*') return false;
	
	memset(dist, -1, sizeof dist);
	dist[S.x][S.y] = 0;
	
	queue<PII> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		if(t == E) return dist[t.x][t.y];  // 防止起点即终点
		
		for(int i = 0; i < 8; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= m) continue;
			if(dist[x][y] != -1 || g[x][y] == '*') continue;  //=='*'，因为起始点都不是'.' ,如果 != '.'，访问不到终点
			
			dist[x][y] = dist[t.x][t.y] + 1;
			q.push({x,y}); 
		}
	}
	return -1;
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> m >> n;  // 看清楚行列
	for(int i = 0; i < n; ++i) 
	{
		cin >> g[i];
		for(int j = 0; j < m; ++j)
		{
			if(g[i][j] == 'K') S = {i,j};
			if(g[i][j] == 'H') E = {i,j};
		}
	}
	
	cout << bfs() << endl;
	
	return 0;
}

六、抓住那头牛

标签：BFS

思路：这道题实际上跟上一题差不多，都是改变坐标，只不过这种方式第一次可能写不出来，但是看了一遍就会了，其余的也只是正常写法。这里说一下为什么小于零，或者大于两倍的 $n$ 就非最优解，因为答案存在于 $0\sim n$ ，能走到零肯定是减到的，所以之后唯一的操作就是加，那就多余走了嘛。然后因为最多也只会走到这，再走明显就不如之前了。

题目描述：

农夫知道一头牛的位置，想要抓住它。

农夫和牛都位于数轴上，农夫起始位于点 N，牛位于点 K。

农夫有两种移动方式：

从 X 移动到 X−1 或 X+1，每次移动花费一分钟从 X 移动到 2∗X，每次移动花费一分钟假设牛没有意识到农夫的行动，站在原地不动。

农夫最少要花多少时间才能抓住牛？

输入格式
共一行，包含两个整数N和K。

输出格式
输出一个整数，表示抓到牛所花费的最少时间。

数据范围
0≤N,K≤105
输入样例：
5 17
输出样例：
4

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 2e5+10, M = N, INF = 0x3f3f3f3f;

int n, m;
int dist[N];

int bfs()
{
	memset(dist, -1, sizeof dist);
	dist[n] = 0;
	
	queue<int> q; q.push(n);
	while(q.size())
	{
		int t = q.front(); q.pop();
		
		if(t == m) return dist[t];
		
		for(int i = 0; i < 3; ++i)
		{
			int x;
			if(!i) x = t - 1;
			else if(i == 1) x = t + 1;
			else x = t * 2;
			
			if(x < 0 || x > N) continue;  // 因为已经非最优解了
			if(dist[x] != -1) continue;
			
			dist[x] = dist[t] + 1;
			q.push(x); 
		}
	}
	return -1;
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	
	cout << bfs() << endl;
	
	return 0;
}

七、矩阵距离

标签：BFS、多源BFS

思路：这道题问的是所有的格子到 $1$ 的最短距离，我们可以反过来从所有的 $1$ 出发，去求到所有的距离，实际做法就是把所有的 $1$ 入队，并把距离初始化为 $0$ ，然后跑一遍 $BFS$ 。

题目描述：

给定一个 N 行 M 列的 01 矩阵 A，A[i][j] 与 A[k][l] 之间的曼哈顿距离定义为：dist(A[i][j],A[k][l])=|i−k|+|j−l|

输出一个 N 行 M 列的整数矩阵 B，其中：B[i][j]=min1≤x≤N,1≤y≤M,A[x][y]=1dist(A[i][j],A[x][y])

输入格式
第一行两个整数 N,M。
接下来一个 N 行 M 列的 01 矩阵，数字之间没有空格。

输出格式
一个 N 行 M 列的矩阵 B，相邻两个整数之间用一个空格隔开。

数据范围
1≤N,M≤1000
输入样例：
3 4
0001
0011
0110
输出样例：
3 2 1 0
2 1 0 0
1 0 0 1

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1010, M = N, INF = 0x3f3f3f3f;

int n, m;
char g[N][N];
int dist[N][N];

int dir[4][2] = {0,1,0,-1,1,0,-1,0};

void bfs()
{
	memset(dist, -1, sizeof dist);
	queue<PII> q;
	
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < m; ++j)
		{
			if(g[i][j] == '1')
			{
				dist[i][j] = 0;
				q.push({i,j});
			}
		}
	}
	
	while(q.size())
	{
		auto t = q.front(); q.pop();
		
		for(int i = 0; i < 4; ++i)
		{
			int x = t.x + dir[i][0];
			int y = t.y + dir[i][1];
			if(x < 0 || x >= n || y < 0 || y >= m) continue;
			if(dist[x][y] != -1) continue;
			
			dist[x][y] = dist[t.x][t.y] + 1;
			q.push({x,y});
		}
	}
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	cin >> n >> m;
	for(int i = 0; i < n; ++i) cin >> g[i];
	
	bfs();
	
	for(int i = 0; i < n; ++i)
	{
		for(int j = 0; j < m; ++j)
		{
			cout << dist[i][j] << " ";
		}
		cout << endl;
	}
	
	return 0;
}

八、魔板

标签：BFS

思路：其实就是状态的表示发生了变化，我用的是如下图的一个对应的顺序，其实这个表示方式不唯一，只要输入输出和变化一一对应即可。我这里面的数字都是下标，这样在变化的时候好理解。总的就是一个 $BFS$ ，然后每次取出队头，进行三种变化，由于字典序最小，就按照 $A BC$ 的顺序，然后有一个哈希表，存的是一对键值都是字符串，分别对应当前的状态，以及从起点到当前状态的操作方式，具体就跟 $d i s t$ 的作用是一样的，还能用 $co u n t$ 方法来看这个状态是否访问过，根据操作方法的顺序来增加操作方法，然后就是具体的操作，我就是根据具体的下标变化，来赋值的。详情见代码，发现结构跟抓住那头牛是一模一样，只是状态和具体的操作不一样了而已。
在这里插入图片描述

题目描述：

Rubik 先生在发明了风靡全球的魔方之后，又发明了它的二维版本——魔板。

这是一张有 8 个大小相同的格子的魔板：

1 2 3 4
8 7 6 5
我们知道魔板的每一个方格都有一种颜色。

这 8 种颜色用前 8 个正整数来表示。

可以用颜色的序列来表示一种魔板状态，规定从魔板的左上角开始，沿顺时针方向依次取出整数，构成一个颜色序列。

对于上图的魔板状态，我们用序列 (1,2,3,4,5,6,7,8) 来表示，这是基本状态。

这里提供三种基本操作，分别用大写字母 A，B，C 来表示（可以通过这些操作改变魔板的状态）：

A：交换上下两行；
B：将最右边的一列插入到最左边；
C：魔板中央对的4个数作顺时针旋转。

下面是对基本状态进行操作的示范：

A：

8 7 6 5
1 2 3 4
B：

4 1 2 3
5 8 7 6
C：

1 7 2 4
8 6 3 5
对于每种可能的状态，这三种基本操作都可以使用。

你要编程计算用最少的基本操作完成基本状态到特殊状态的转换，输出基本操作序列。

注意：数据保证一定有解。

输入格式
输入仅一行，包括 8 个整数，用空格分开，表示目标状态。

输出格式
输出文件的第一行包括一个整数，表示最短操作序列的长度。

如果操作序列的长度大于0，则在第二行输出字典序最小的操作序列。

数据范围
输入数据中的所有数字均为 1 到 8 之间的整数。

输入样例：
2 6 8 4 5 7 3 1
输出样例：
7
BCABCCB

示例代码：

#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int,int> PII;
#define x first
#define y second

const int N = 1e5+10, M = N, INF = 0x3f3f3f3f;

int n, m;
unordered_map<string,string> dist;
string S = "12345678", E;

string dir = "ABC";

string op1(string src)
{
	string res = src;
	for(int i = 0; i < 4; ++i)
	{
		swap(res[i], res[7-i]);
	}
	return res;
}

string op2(string src)
{
	string res = src;
	int t[8] = {3,0,1,2,5,6,7,4};
	for(int i = 0; i < 8; ++i)
	{
		res[i] = src[t[i]];
	}
	return res;
}

string op3(string src)
{
	string res = src;
	res[1] = src[6], res[2] = src[1];
	res[5] = src[2], res[6] = src[5];
	return res;
}

string bfs()
{
	dist[S] = "";
	
	queue<string> q; q.push(S);
	while(q.size())
	{
		auto t = q.front(); q.pop();
		if(t == E) return dist[E];
		
		for(int i = 0; i < 3; ++i)
		{
			string x;
			if(!i) x = op1(t);
			else if(i == 1) x = op2(t);
			else x = op3(t);
			
			if(dist.count(x)) continue;
			
			dist[x] = dist[t] + dir[i];
			q.push(x); 
		}
	}
	return "impossible";
}

int main()
{
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	
	string t; 
	while(cin >> t) E += t;
	
	string res = bfs();
	cout << res.size() << endl;
	if(res.size()) cout << res << endl;
	
	return 0;
}