PAT 万绿丛中一点红的代码实现及错误分析附带PAT内存限制一点想法（C语言）

题目

对于计算机而言，颜色不过是像素点对应的一个 24 位的数值。现给定一幅分辨率为 M×N 的画，要求你找出万绿丛中的一点红，即有独一无二颜色的那个像素点，并且该点的颜色与其周围 8 个相邻像素的颜色差充分大。

输入格式：

输入第一行给出三个正整数，分别是 M 和 N（≤ 1000），即图像的分辨率；以及 TOL，是所求像素点与相邻点的颜色差阈值，色差超过 TOL 的点才被考虑。随后 N 行，每行给出 M 个像素的颜色值，范围在 [0,2​24​​) 内。所有同行数字间用空格或 TAB 分开。

输出格式：

在一行中按照 (x, y): color 的格式输出所求像素点的位置以及颜色值，其中位置 x 和 y 分别是该像素在图像矩阵中的列、行编号（从 1 开始编号）。如果这样的点不唯一，则输出 Not Unique；如果这样的点不存在，则输出 Not Exist。

输入样例 1：

8 6 200
0 	 0 	  0 	   0	    0 	     0 	      0        0
65280 	 65280    65280    16711479 65280    65280    65280    65280
16711479 65280    65280    65280    16711680 65280    65280    65280
65280 	 65280    65280    65280    65280    65280    165280   165280
65280 	 65280 	  16777015 65280    65280    165280   65480    165280
16777215 16777215 16777215 16777215 16777215 16777215 16777215 16777215

输出样例 1：

(5, 3): 16711680

输入样例 2：

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

输出样例 2：

Not Unique

输入样例 3：

3 3 5
1 2 3
3 4 5
5 6 7

输出样例 3：

Not Exist

实现思路：存入颜色数据，循环遍历所有元素，判断是否有重复，判断与周围元素的差值是否超过阈值。

第一个小坑：最外围一圈元素也需要判断，隐藏条件并非与周围8个元素比较，而是与周围存在的元素比较，这样就需要区分很多情况去分类比较。这里采用取巧的方法，即在输入数据之外补充一圈0，然后统一成判断周围8个元素，但这样有个漏洞，就是当某元素与0的差值小于阈值而与周围存在的数据的差值大于阈值时会被判断成不满足，而实际是满足条件。例如：

阈值：5
000  000 000
000  001 010
000  010 011

如果001唯一的话，应该是满足条件的，但这样判别会错判。好在测试用例没有这种情况。

第二个小坑：题目对颜色大小的设置，如果采用足够覆盖所有颜色范围的标志位来判断元素是否唯一的话，如果在main函数中定义flag[2^24]={0}，则必定出现所有测试段错误的情况，即空间不足，简单计算可知，int类型为4个字节，则2^20个int即为4M，而2^24个int刚好为64M，而题目限定整个程序运行空间为64M，所以错误，即使改为short类型或者unsigned char类型也依然会段错误，因此运行空间限制中我们开辟的数组空间很有限。在浏览网友的杰作时，意外发现，如果把数组定义为全局数组，则运行通过，而且该网友程序段中出现a[-1][-1]这样的越界情况都可以完美通过测试，故猜测全局变量不在限制空间范围内（下面我会给出采用全局变量的方法，不过去除了越界情况）。

1.采用全局变量的代码实现：

#include<stdio.h>
#include<math.h>

int iData[1002][1002]={0};//定义足够大数组，余出最外面一圈0
int iFlag[2<<24]={0};//定义2的24次方的标志位

int judge(int r, int c, int value)//判断函数
{
  int flag=1;
  if(iFlag[iData[r][c]]!=1)
  {
    flag=0;
  }
  else
  {
    for(int i=r-1;i<=r+1;i++)
    {
      for(int j=c-1;j<=c+1;j++)
      {
        if(i==r&&j==c)
        {
          continue;
        }
        else
        {
          if((int)abs(iData[i][j]-iData[r][c])<=value)//abs函数为double，需要转换为int
          {
            flag=0;
            break;
          }
        }
      }
      if(flag==0)//双重退出
      {
        break;
      }
    }
  }
  return flag;
}

int main()
{
  int N=0,M=0,iValue=0;
  scanf("%d%d%d",&M,&N,&iValue);
  // int iData[N][M],iFlag[2<<24]={0};
  // int iData[N][M],iFlag[16777216]={0};
  for(int i=1;i<N+1;i++)//把最外面一圈的0空出来
  {
    for(int j=1;j<M+1;j++)
    {
      scanf("%d",&iData[i][j]);
      iFlag[iData[i][j]]++;
    }
  }
  
  int iCnt=0;
  int x=0,y=0,z=0;
  for(int i=1;i<N+1;i++)//只判断输入数据的范围
  {
    for(int j=1;j<M+1;j++)
    {
      if(judge(i,j,iValue))
      {
        iCnt++;
        x=j;
        y=i;
        z=iData[i][j];
      }
    }
  }
  
  if(iCnt==0)
  {
    printf("Not Exist");
  }
  else if(iCnt==1)
  {
    printf("(%d, %d): %d",x,y,z);
  }
  else
  {
    printf("Not Unique");
  }
  return 0;
}

2.不采用全局变量的代码实现

这里因为采用了最小空间的做法，定义数组时采用了变量，所以无法把判断函数分离出去，就都写一起了，如果要分离函数的话，因为是二维数组，所以参数传递时需要写成a[][1002]的方式，即定义数组时至少列数据是常数。

#include<stdio.h>
#include<math.h>

int main()
{
  int N=0,M=0,iValue=0;
  scanf("%d%d%d",&M,&N,&iValue);
  int iData[N+2][M+2];//比数据多一圈
  for(int i=0;i<N+2;i++)
  {
    for(int j=0;j<M+2;j++)
    {
    	if(i==0||i==N+1||j==0||j==M+1)//外圈赋值为0
    	{
    		iData[i][j]=0;
		}
		else
		{
      	    scanf("%d",&iData[i][j]);
        }
    }
  }
  
  int iCnt=0,iF1=1,iF2=1;//是否唯一的标志，是否阈值符合的标志
  int x=0,y=0,z=0;
  for(int i=1;i<N+1;i++)
  {
    for(int j=1;j<M+1;j++)
    {
    	iF1=1;//循环遍历是否唯一
    	for(int p=1;p<N+1;p++)
    	{
    		for(int q=1;q<M+1;q++)
    		{
    			if(p==i&&q==j)
    			{
    				continue;
				}
				else if(iData[i][j]==iData[p][q])
				{
  					iF1=0;
  					break;
			    }
  			}
  			if(iF1==0)//双重退出
  			{
  				break;
  			}
		  }
		  if(iF1==0)//若不唯一，检验下一个元素
		  {
		    continue;
		  }
     
        iF2=1;//检验九宫格阈值是否符合
        for(int m=i-1;m<=i+1;m++)
        {
          for(int n=j-1;n<=j+1;n++)
          {
          	if(m==i&&n==j)
          	{
          		continue;
			}
			else if((int)abs(iData[i][j]-iData[m][n])<=iValue)
            {
              iF2=0;
              break;
            }
          }
          if(iF2==0)//双重退出
          {
            break;
          }
        }
        
        if(iF1==1&&iF2==1)//若都符合，则输出并计数，这里因为外圈加了0，所以不用加1
        {
          x=j;
          y=i;
          z=iData[i][j];
          iCnt++;
        }
        if(iCnt>1)//若超出一个则退出
        {
          break;
        }
    }
    if(iCnt>1)//双重退出
    {
      break;
    }
  }
  //输出
  if(iCnt==0)
  {
    printf("Not Exist");
  }
  else if(iCnt==1)
  {
    printf("(%d, %d): %d",x,y,z);
  }
  else
  {
    printf("Not Unique");
  }
  return 0;
}

错误分析：

1.边界数据的判断；

2.如果采用加一圈0的做法，最后输出位置时则不需要再加1。