CCF-消除类游戏（图的遍历，数组一定开大（不知为何））

问题描述

消除类游戏是深受大众欢迎的一种游戏，游戏在一个包含有n行m列的游戏棋盘上进行，棋盘的每一行每一列的方格上放着一个有颜色的棋子，当一行或一列上有连续三个或更多的相同颜色的棋子时，这些棋子都被消除。当有多处可以被消除时，这些地方的棋子将同时被消除。
　　现在给你一个n行m列的棋盘，棋盘中的每一个方格上有一个棋子，请给出经过一次消除后的棋盘。
　　请注意：一个棋子可能在某一行和某一列同时被消除。

输入格式

输入的第一行包含两个整数n, m，用空格分隔，分别表示棋盘的行数和列数。
　　接下来n行，每行m个整数，用空格分隔，分别表示每一个方格中的棋子的颜色。颜色使用1至9编号。

输出格式

输出n行，每行m个整数，相邻的整数之间使用一个空格分隔，表示经过一次消除后的棋盘。如果一个方格中的棋子被消除，则对应的方格输出0，否则输出棋子的颜色编号。

样例输入

4 5
2 2 3 1 2
3 4 5 1 4
2 3 2 1 3
2 2 2 4 4

样例输出

2 2 3 0 2
3 4 5 0 4
2 3 2 0 3
0 0 0 4 4

样例说明

棋盘中第4列的1和第4行的2可以被消除，其他的方格中的棋子均保留。

样例输入

4 5
2 2 3 1 2
3 1 1 1 1
2 3 2 1 3
2 2 3 3 3

样例输出

2 2 3 0 2
3 0 0 0 0
2 3 2 0 3
2 2 0 0 0

样例说明

棋盘中所有的1以及最后一行的3可以被同时消除，其他的方格中的棋子均保留。

评测用例规模与约定

所有的评测用例满足：1 ≤ n, m ≤ 30。
　　解题思路：
　　利用结构体来存可以消去的元素的坐标，最后遍历结构体数组将二维数组赋0；调试时注意边界，结构体数组大小也很关键。我的存储方式决定了找3连比较时的方式，所以还是比较麻烦。
　　令一种方法是建立另外一个标记型二维数组，把符合条件的在标记数组上做标记，最后对比标记数组来改变输入的数组。这种存储方式可以利用以下方法进行比较：

 for(i=0; i<n; i++)
        for(j=0; j<m-2; j++)
            if(a[i][j]== a[i][j + 1] && a[i][j + 1] == a[i][j +2])

我的方法与大佬的差太多，还需要继续锻炼，以下是我的满分代码：

#include<iostream>
using namespace std;
int a[32][32];
int m,n;
struct node{
	int s;
	int l;
	int ss;
}que1[500],que2[500];//数组开小了，一直90分。注意！ 
int main(){
	cin>>n>>m;
	int res;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			cin>>a[i][j];
		}
	}
	int cnt=1;
	int cou1=0,cou2=0;
	for(int i=0;i<n;i++){
	//一行中
		cnt=1;
		for(int j=m-1;j>=0;j--){
			if(j&&a[i][j]==a[i][j-1]){
				cnt++;
			}
			 if(j&&cnt<3&&a[i][j-1]!=a[i][j]){
				cnt=1;
			}
			//cout<<"cnt:"<<cnt<<" J:"<<j<<endl;
			 if(cnt>=3&&(j==0||a[i][j-1]!=a[i][j])){
				que1[cou1].s=j;
				que1[cou1].ss=i;//位于哪一行 
				que1[cou1].l=cnt;
				//cout<<"l  "<<que1[cou1].l<<endl;
				cou1++; 
				cnt=1;
				
			}
		}
	}
	//cout<<"**"<<que1[0].l<<endl;
	for(int i=0;i<m;i++){//一列中
		cnt=1;
		for(int j=n-1;j>=0;j--){
			if(j&&a[j][i]==a[j-1][i]){
				cnt++;
			}
			if(j&&cnt<3&&a[j-1][i]!=a[j][i]){
				cnt=1;
			}
			if(cnt>=3&&(a[j-1][i]!=a[j][i]||j==0)){
				que2[cou2].s=j;
				que2[cou2].l=cnt;
				que2[cou2].ss=i;//位于哪一列 
				cou2++; 
				cnt=1;
			}
		}
	}
	/*cout<<"cout1   "<<cou1<<endl;
	cout<<"l  "<<que1[0].l<<endl;
	cout<<"ss "<<que1[0].ss<<endl;;*/
	for(int i=0;i<cou1;i++){//消除一行 
		for(int j=0;j<que1[i].l;j++){
			a[que1[i].ss][que1[i].s+j]=0;
		} 	 
	}
	for(int i=0;i<cou2;i++){//消除一列 
		for(int j=0;j<que2[i].l;j++){
			//cout<<"**"<<endl;
			a[que2[i].s+j][que2[i].ss]=0;
		} 	 
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}
	return 0;
}
/*
4 5
 6 9 8 8 8
 9 9 9 1 8
 6 9 1 1 8
 6 2 6 1 6
 //注意边边角角的样例 
 */

第二遍做有了好思路，把每一个点的判定当作一个模块，然后利用迭代进行操作即可，在镜像数组中标记应该清零的数，最后输出时结合其进行输出即可。
但是当我把g【】【】数组开城g【50】【50】才得60分，当我把g定义为【1000】【1000】才可以的满分。这里还不知道为何，需要注意！

#include<iostream>
#include<cstdio>
using namespace std;
int g[1010][1010];
int tmp[50][50]; 
int n,m;
void deal(int x,int y,int z){
 if(g[x][y]!=z) return ;
 if((x<n-1||x>0)&&g[x+1][y]==z&&g[x-1][y]==z){
  tmp[x][y]=z;
  if(tmp[x+1][y]!=z){
   tmp[x+1][y]=z;
   deal(x+1,y,z);
  }
  if(tmp[x-1][y]!=z){
   tmp[x-1][y]=z;
   deal(x-1,y,z);
  }  
 }
 if((y<m-1||y>0)&&g[x][y+1]==z&&g[x][y-1]==z){
  tmp[x][y]=z;
  if(tmp[x][y+1]!=z){
   tmp[x][y+1]=z;
   deal(x,y+1,z);
  }
  if(tmp[x][y-1]!=z){
   tmp[x][y-1]=z;
   deal(x,y-1,z);
  }  
 }
}
int main(){
 cin>>n>>m;
 for(int i=0;i<n;i++){
  for(int j=0;j<m;j++){
   cin>>g[i][j];
  }
 }
 for(int i=0;i<n;i++){
  for(int j=0;j<m;j++){
   deal(i,j,g[i][j]);
  }
 }
 for(int i=0;i<n;i++){
  for(int j=0;j<m;j++){
   if(tmp[i][j]){
    cout<<0<<" ";
   }
   else {
    cout<<g[i][j]<<" ";
   }
  }
  cout<<endl;
 }
 return 0;
}