994. 腐烂的橘子-非递归法

994. 腐烂的橘子

在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。

每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

示例 1：

输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4

示例 2：

输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。

示例 3：

输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
解题代码如下：

int orangesRotting(int** grid, int gridSize, int* gridColSize){
    
    int n=gridSize;
    int m=gridColSize[0];
    int fresh_man[m*n][2];
    int num=0;
    int i,j;
    int size=0;
    for(i=0;i<n;i++){
    
        for(j=0;j<m;j++){
    
            if(grid[i][j]==1){
    
                fresh_man[size][0]=i;
                 fresh_man[size][1]=j;
                 size++;

            }

        }
    }
    int drection[4][2]={
    {
    0,1},{
    1,0},{
    0,-1},{
    -1,0}};
int epo=0;
while(size!=0){
    
   
    int num_sub=0;
    for(i=0;i<size;i++){
    
      
         int x=fresh_man[i][0];
         int y=fresh_man[i][1];
      
         for(j=0;j<4;j++){
    
             int newx=x+drection[j][0];
             int newy=y+drection[j][1];
          
             if(newx>=0&&newx<n&&newy>=0&&newy<m){
    
                 
               
                 if(grid[newx][newy]==2){
    
                 size--;
              

                   int tx=fresh_man[i][0];
                   int ty=fresh_man[i][1];
                   num_sub++;
                   fresh_man[i][0]=fresh_man[size][0];
                    fresh_man[i][1]=fresh_man[size][1];
                    fresh_man[size][0]=tx;
                    fresh_man[size][1]=ty;
                       i--;
                   break;
                 }
             }
         }
      


    }
    for(i=0;i<num_sub;i++){
    
        grid[fresh_man[size+i][0]][fresh_man[size+i][1]]=2;

    }
 // printf("size %d numsub %d ",size,num_sub);
   
   epo++;
    if(num_sub==0){
    
        break;
    }

}
if(size!=0)return -1;
return epo;

}