116. 飞行员兄弟(枚举，bfs，dfs)

/*由于本题改变改变一个把手，就会改变一整行一整列
这意味着我们改变一次就会改变之前已经修改好的情况，所以我们不应该再使用递推的方法
但是本题的方格数较小，这意味着我们可以使用dfs，bfs还有枚举的方法*/

1.dfs的方法

#include <iostream>
#include <cstring>
using namespace std;
const int N = 5;
int res=10000;
char g[N][N];
typedef pair<int, int> PII;
PII ans[N*N];
PII tmp[N*N];
const int D = 4;
/*dfs:枚举一个方格两种情况，按或者不按，记得回溯*/
void turn_one(int x, int y)
{
	if (g[x][y] == '+') g[x][y] = '-';
	else g[x][y] = '+';
}

void turn_all(int x, int y)
{//一行，一列全部按掉
	for (int i = 0;i < 4;i++)
	{
		turn_one(x, i);		//当前行
		turn_one(i, y);		//当前列
	}
	turn_one(x, y);
}
void dfs(int x, int y,int step)
{
	if (x < 0 || y < 0)
		return;
	if (y == D)		//到达边界
	{
		x = x + 1;
		y = 0;
		dfs(x, y,step);
		return;
	}
	if (x == D)	//全部枚举完了
	{//判断是否最优
		for (int i = 0;i < 4;i++)
			for (int j = 0;j < 4;j++)
				if (g[i][j] == '+')return;
		if (res > step)
		{
			memcpy(ans, tmp, sizeof ans);
			res = step;
		}
		return;
	}
	//按了当前开关
	turn_all(x, y);	//操作了一次
	tmp[step] = { x + 1,y + 1 };
	dfs(x, y + 1,step+1);
	//不按当前开关
	turn_all(x, y);	//回溯
	tmp[step] = { 0,0 };
	dfs(x, y + 1,step);
}
int main()
{
	for (int i = 0;i < 4;i++)
		cin >> g[i];
	dfs(0, 0, 0);
	cout << res<<'\n';
	for (int i = 0;i < res;i++)
		cout << ans[i].first<<' '<< ans[i].second << '\n';
}

2.bfs宽度优先搜索(超时，用不了)

#include <iostream>
#include <cstring>
#include <queue>
#include <unordered_map>
#define x first
#define y second
using namespace std;
const int N = 5;
int res = 10000;
char g[N][N];
typedef pair<int ,int > PII;
PII ans[N * N];
PII tmp[N * N];
const int D = 4;
/*bfs的方法和八数码一样，存储一个当前的字符串，应用宽度优先搜索找出最小操作次数
只要找到了，一定是最优解
*/
typedef pair<string, int> P;
queue<P> q;
string turn_one(string t, int pos)
{
	string tmp = t;
	if (tmp[pos] == '+') tmp[pos] = '-';
	else tmp[pos] = '+';
	return tmp;
}
string turn_all(string s,int pos)
{
	string t = s;
	int a = pos / 4, b = pos % 4;
	for (int i = a * 4;i < (a + 1) * 4;i++)	//同一行
	{
		t=turn_one(t, i);
	}
	for (int i = 0;i < 4;i++)
	{
		t = turn_one(t, i * 4 + b);
	}
	t = turn_one(t, pos);
	return t;
}
int bfs()
{
	string start;
	for(int i=0;i<4;i++)
		for (int j = 0;j < 4;j++)
		{
			char c = g[i][j];
			start += c;
		}
	//0表示当前要操作第0个位置的字符
	q.push({ start,0 });
	string end = "----------------";
	unordered_map<string ,int > st;
	st[start] = 0;
	while (q.size())
	{
		P v = q.front();
		q.pop();
		if (v.x == end) return st[v.x];
		//按开关
		if (v.y >= 16) continue;
		string t = turn_all(v.x,v.y);
		if (!st.count(t)&&v.y<16)	//没有被访问过
		{
			st[t] = st[v.x] + 1;	//操作次数+1
			q.push({ t,v.y + 1 });		//应该修改下一位
		}
		//不按开关
		if(v.y<16)
			q.push({ v.x,v.y + 1 });
	}
	return -1;
}
int main()
{
	for (int i = 0;i < 4;i++)
		cin >> g[i];
	cout<<bfs();

	
}

3.位运算枚举

#include <iostream>
#include <algorithm>
#include <cstring>
#define x first
#define y second
using namespace std;
const int N = 5;
char g[N][N];
typedef pair<int, int> PII;
PII ans[N*N];
PII t[N * N];
char tmp[N][N];	//中间数组
//由于只有16个格子，我们可以考虑每个格子都有两种选择
//一种是按，一种是不按，那样子的话，时间复杂度是O(2^16)
//本题可以考虑
void turn_one(int x, int y)
{
	if (g[x][y] == '-') g[x][y] = '+';
	else g[x][y] = '-';
}
void turn_all(int x, int y)
{
	for (int i = 0;i < 4;i++)
	{
		turn_one(x, i);
		turn_one(i, y);
	}
	turn_one(x, y);
}
int main()
{
	int res = 100;
	for (int i = 0;i < 4;i++)
		cin >> g[i];
	for (int i = 0;i < 1 << 16;i++)	//2^16
	{	int step = 0;
		memset(t, 0, sizeof t);
		memcpy(tmp, g, sizeof g);
		
		for (int j = 0;j < 16;j++)
		{//需要把j给改成二维坐标
			int k = i >> j & 1;
			if (k)	//要操作
			{
				int x = j / 4, y=j % 4;
				//注意这里是j
				turn_all(x, y);
				t[step++] = { x + 1,y + 1 };
			}
		}
		bool flag = true;
		for (int j = 0;j < 4;j++)
			for (int k = 0;k < 4;k++)
				if (g[j][k] == '+')
					flag = false;
		if (flag)	//更新值
		{
			if (res > step)
			{
				res = step;
				memcpy(ans, t, sizeof ans);
			}
		}
		memcpy(g, tmp, sizeof g);
	}
	cout << res << '\n';
	for (int i = 0;i < res;i++)
		cout << ans[i].x << ' ' << ans[i].y << '\n';
}