542.01矩阵

给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。

两个相邻元素间的距离为 1 。

示例 1:
输入:

0 0 0
0 1 0
0 0 0

输出:

0 0 0
0 1 0
0 0 0

示例 2:
输入:

0 0 0
0 1 0
1 1 1

输出:

0 0 0
0 1 0
1 2 1

注意:

给定矩阵的元素个数不超过 10000。
给定矩阵中至少有一个元素是 0。
矩阵中的元素只在四个方向上相邻: 上、下、左、右。

来源：力扣（LeetCode）

---

记录一下。开始思路想的挺好，感觉也不错。
提交，错。。。。
栈一直溢出，我就想着？？？最终发现可能是走了重复的路。于是设置了变量保存走过的路，答案是对了，不过超时了。我太难了。
但是不错，递归大体思路是正确的，有些想不到的地方正是自己要提高的嘛。

class Solution {
public:
   
    int x[4]={0,0,-1,1};
    int y[4]={1,-1,0,0};
    int tep=0x3f3f3f3f;
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        vector<vector<int>>flag(matrix.size(),vector<int>(matrix[0].size(),0));
         vector<vector<int>>tflag(matrix.size(),vector<int>(matrix[0].size(),0));
        vector<vector<int>>ans(matrix.size(),vector<int>(matrix[0].size()));
        for(int i=0;i<matrix.size();i++){
            for(int j=0;j<matrix[0].size();j++){
                if(matrix[i][j]==0) ans[i][j]=0;
                else {
                    dfs(matrix,i,j,0,flag);
                    ans[i][j]=tep;
                    tep=0x3f3f3f3f;
                }
            }
        }
        return ans;
    }
    void dfs(vector<vector<int>>& matrix,int px,int py,int cot,vector<vector<int>> flag){
        if(px<0||py<0||px>=matrix.size()||py>=matrix[0].size()) return;
        if(flag[px][py]==1) return;
        if(cot+1>=tep) return;
        //先看看这个1周围有没有0。有的话直接返回1
        for(int i=0;i<4;i++){
            if(px+x[i]<0||py+y[i]<0||px+x[i]>=matrix.size()||py+y[i]>=matrix[0].size());
            else{
                if(matrix[px+x[i]][py+y[i]]==0){
                    tep=min(tep,cot+1);
                    //if(coo==18) cout<<"tep="<<tep<<endl;
                    return;
                }
            }
        }
        flag[px][py]=1;
        if(tep==2) return;
        //四周没有1，开始递归查找四边的。
        for(int i=0;i<4;i++){   
            dfs(matrix,px+x[i],py+y[i],cot+1,flag);
        }
    }
};

---

自己写的是当前为1的话，递归寻找身边所有到达0的路径，找出路径距离最小的即可。这样的话每个1都要查找整个矩阵。
看到一种想法是，逆向思维，当前为0的话，递归寻找身边的1。这样递归的深度减少很多。
首先在原数组上进行操作。先遍历每个值，如果当前为1并且直连的四周没有0，则把他置为一个较大的值max。之后再对数组里面的0进行深搜，修改周围非0非1的元素值的大小。
由于是每一个0都进行深搜，所以最终保证了结果的正确性。

vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        for(int i=0;i<matrix.size();i++){
            for(int j=0;j<matrix[0].size();j++){
                if(matrix[i][j]==1&&!(
                    (i>0&&matrix[i-1][j]==0)
                    ||(i<matrix.size()-1&&matrix[i+1][j]==0)
                    ||(j>0&&matrix[i][j-1]==0)
                    ||(j<matrix[0].size()-1&&matrix[i][j+1]==0)) ){
                    //当前为1并且周围都是1，才置为最大。
                    matrix[i][j]=INT_MAX;
                }
               
            }
        } 
        int cot=0;
        for(int i=0;i<matrix.size();i++){
            for(int j=0;j<matrix[0].size();j++){
              if(matrix[i][j]==0)  dfs(matrix,i,j,cot);
            }
        }
        return matrix;
    }
    void dfs(vector<vector<int>>& matrix,int x,int y,int cot){
        if(x<0||x>=matrix.size()||y<0||y>=matrix[0].size()) return;
        if(matrix[x][y]<cot) return;//
        matrix[x][y]=cot;
        dfs(matrix,x+1,y,cot+1);
        dfs(matrix,x-1,y,cot+1);
        dfs(matrix,x,y+1,cot+1);
        dfs(matrix,x,y-1,cot+1);
    }

当时写成

j<=matrix[0].size()-2&&matrix[i][j+1]==0

数组就越界，原因是size()返回无符号整型，如果直接-2，按照运算自动提升，也转化为无符号。