连连看算法

题目描述：

”连连看“：给定一个棋盘，有很多棋子，如果某两个相同的棋子，可以通过一条线连起来（这条线不能经过其他棋子），而且线的转折次数不超过两次，连线不能从外围绕过，这两个棋子就可以从棋盘上消去。请你写一个程序，判定给定的两个方格能不能消去。 

输入描述：

输入数据有多组，每组数据的第一行有两个正整数n，m（0<n<=1000,0<m<1000)，分别表示棋盘的行数与列数。在接下来的n行中，每行有m个非负整数描述棋盘的方格分布。0表示这个位置没有棋子，正整数表示棋子的类型。接下来的一行是一个正整数q(0<q<50)，表示下面有q次询问。在接下来的q行里，每行有四个正整数x1,y1,x2,y2，表示询问第x1行y1列的棋子与x2行y2列的棋子能不能消去，n=0,m=0时输入结束

注意：询问之间无先后顺序，都是针对当前状态的

输出描述：

每一组输入数据对应一行输出。如果能消去则输出"yes"，不能输出"NO"

示例：

输入：

3   4

1  2  3  4

0  0  0  0

4  3  2  1

4

1  1  3  4

1  1  2  4

1  1  3  3

2  1  2  4

0  0

输出：

YES

NO

NO

NO

 由于题目要求拐点数不能超过2个，所以两个方格之间满足要求的连线有0个拐点、1个拐点和2个拐点三种情况

1）0个拐点，即一条直线

那么A、B两个点一定在一条线上，具体又分为两种情况：

(2) 1个拐点

要想只有一个拐点,那么AB两点肯定不在一条线上(一条线上的两点连接,要么没有拐点,要么两个拐点),并且拐点是以A和B为对角点的矩形的另两个对角点

(3) 2个拐点

根据递归的思想，判断A单元格与B单元格能否经过两个拐点连接，可以转化为判断能否找到一个C单元格，该C单元格可以与A单元格0折连接，且C与B可以1折连接。若能找到这样一个C单元格，那么A与B就可以2折连接

可以以一个单元格为起点,如A,在其上、下、左、右四个方向进行扫描，找到符合条件的C单元，再进行B、C单元的一折检查

以上图片来自其他博客

下面是自己写的代码:

#include<iostream>
#include<vector>

using namespace std;
int n,m;   //棋盘的行和列
vector<vector<int>> chessboard;
// 0折连接
bool check0(vector<int> points)
{
	int x1=points[0],x2=points[2];
	int y1=points[1],y2=points[3];
	//在一条水平线上
	if(x1==x2)
	{
		int min=y1<y2?y1:y2;
		int max=y1>y2?y1:y2;
		for(int i=min+1;i<max;i++)
		{
			if(chessboard[x1][i]!=0)
				return false;
		}
		return true;
	}
	//在一条垂线上
	if(y1==y2)
	{
		int min=x1<x2?x1:x2;
		int max=x1>x2?x1:x2;
		for(int i=min+1;i<max;i++)
		{
			if(chessboard[i][y1]!=0)
				return false;
		}
		return true;
	}
	return false;
}
//  1折连接
bool check1(vector<int> points)
{
	int x1=points[0],x2=points[2];
	int y1=points[1],y2=points[3];
	if(x1!=x2 && y1!=y2)   // 1折连接的两个点既不在一行也不在一列
	{
		if(chessboard[x1][y2]==0)
		{
			vector<int> newpoint1(points);
			newpoint1[2]=x1;
			vector<int> newpoint2(points);
			newpoint2[1]=y2;
			bool res=check0(newpoint1) && check0(newpoint2);
			if(res)
				return true;
		}
		if(chessboard[x2][y1]==0)
		{
			vector<int> newpoint1(points);
			newpoint1[3]=y1;
			vector<int> newpoint2(points);
			newpoint2[0]=x2;
			bool res=check0(newpoint1) && check0(newpoint2);
			if(res)
				return true;
		}
		return false;
	}

}
// 2折连接
bool check2(vector<int> points)
{
	int x1=points[0],x2=points[2];
	int y1=points[1],y2=points[3];
	bool res;
	if(x1==x2 || y1==y2)
	{
		res=check0(points);
	}
	else
	{
		res=check1(points);
	}
		
	if(res)
		return true;
	// 2折检查
	for(int i=x1+1;i<n;i++)
	{
		if(chessboard[i][y1]==0)
		{
			vector<int> newpoint(points);
			newpoint[0]=i;
			bool res=check1(newpoint);
			if(res)
				return true;
		}
		else
			break;
	}
	for(int i=x1-1;i>=0;i--)
	{
		if(chessboard[i][y1]==0)
		{
			vector<int> newpoint(points);
			newpoint[0]=i;
			bool res=check1(newpoint);
			if(res)
				return true;
		}
		else
			break;
	}
	for(int i=y1-1;i>=0;i--)
	{
		if(chessboard[x1][i]==0)
		{
			vector<int> newpoint(points);
			newpoint[1]=i;
			bool res=check1(newpoint);
			if(res)
				return true;
		}
		else
			break;
	}
	for(int i=y1+1;i<m;i++)
	{
		if(chessboard[x1][i]==0)
		{
			vector<int> newpoint(points);
			newpoint[1]=i;
			bool res=check1(newpoint);
			if(res)
				return true;
		}
		else
			break;
	}
	return false;
}
bool elimination(vector<int> points)
{
	if(chessboard[points[0]][points[1]]==0 ||chessboard[points[2]][points[3]]==0)
		return false;
	if(chessboard[points[0]][points[1]] != chessboard[points[2]][points[3]])
		return false;
	else
		return check2(points);
}

int main()
{
	
	cin>>n>>m;
	for(int i=0;i<n;i++)
	{
		vector<int> row;
		for(int j=0;j<m;j++)
		{
			int temp;
			cin>>temp;
			row.push_back(temp);
		}
		chessboard.push_back(row);
	}
	int q;
	cin>>q;
	vector<vector<int>> check;
	for(int i=0;i<q;i++)
	{
		vector<int> row;
		for(int j=0;j<4;j++)
		{
			int temp;
			cin>>temp;
			row.push_back(temp-1);
		}
		check.push_back(row);
	}
    int n1,m1;
	cin>>n1>>m1;
	for(int i=0;i<q;i++)
	{
		bool res=elimination(check[i]);
		if(res)
		  cout<<"YES"<<endl;
		else
		  cout<<"NO"<<endl;
	}
	return 0;
}

输出: