542. 01 Matrix

Given a matrix consists of 0 and 1, find the distance of the nearest 0 for each cell.

The distance between two adjacent cells is 1.

Example 1:
Input:

0 0 0
0 1 0
0 0 0

Output:

0 0 0
0 1 0
0 0 0

Example 2:
Input:

0 0 0
0 1 0
1 1 1

Output:

0 0 0
0 1 0
1 2 1

Note:

1. The number of elements of the given matrix will not exceed 10,000.
2. There are at least one 0 in the given matrix.
3. The cells are adjacent in only four directions: up, down, left and right.

居然（终于）AC了，主要思想是最短路径

首先将矩阵中为0的元素位置入队，然后开始BFS，同时不断更新每个位置上1到0的最短距离，这里主要是从Dijkstra来的思想

class Solution {
public:      
    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {  
        vector<vector<int>> ans;
        queue<pair<int, int>> q;
        vector<vector<bool>> vis;               //标记数组，开不了10000的二维数组，只能用vector了...
        const int INF = 0x3f3f3f3f;
        for(int i = 0; i < matrix.size(); i++)  //标记数组初始化
        {
            vector<bool> t(matrix[i].size(), 0);
            vis.push_back(t);
        }
        for(int i = 0; i < matrix.size(); i++)
        {
            vector<int> temp;
            for(int j = 0; j < matrix[i].size(); j++)
            {
                if(matrix[i][j] == 0)
                {
                    q.push(make_pair(i, j));
                    vis[i][j] = 1;
                    temp.push_back(0);
                }
                else
                {
                    temp.push_back(INF);      //初始化每个位置上的1与最近0的距离为INF
                }
            }
            ans.push_back(temp);
        }
        int X[4] = {0, 0, 1, -1}, Y[4] = {1, -1, 0, 0};
        while(!q.empty())
        {
            pair<int, int> p = q.front();
            q.pop();          
            for(int i = 0; i < 4; i++)
            {
                int x = p.first + X[i], y = p.second + Y[i];
                if(x >= 0 && x < ans.size() && y >= 0 && y < ans[x].size())
                {
                    if(ans[p.first][p.second] + 1 < ans[x][y])    //更新距离
                            ans[x][y] = ans[p.first][p.second] + 1;
                    if(!vis[x][y])
                    {
                        q.push(make_pair(x, y));
                        vis[x][y] = 1;
                    }
                }              
            }           
        }
        return ans;
    }
};