[LeetCode] 01 Matrix 题解

题意

题目

思路

我一开始的时候想的是最简单的方法，就是遍历所有的值为1的元素，再根据其为起点进行BFS，计算层数，但是这个方法超时了；

其实，可以不用从1开始遍历，从0开始遍历，找到和值为1相邻的0，将其的层数设置为1就行了，为什么可以不用从1开始，因为并没有要求从规定的起点到指定的位置，计算最小距离，而是计算一整个周围，只要周围存在1，则将其加入到队列，计算相应的距离（又可能存在别多个1包围的1的情况），注意的是，在访问过1的结点后下次不可以再进行计算。

实现

//
//

#include "../PreLoad.h"

class Solution {
public:

    /**
     * 三重循环，最外层为所有1的结点，里面两层是实现BFS
     * 导致时间复杂度过高，待优化
     * @param matrix
     * @return
     */
    vector< vector<int>> layouts = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    vector<vector<int>> updateMatrix(vector<vector<int>>& matrix) {
        vector<vector<int>> result(matrix);
        if (matrix.size() == 0) {
            return result;
        }

        size_t row = matrix.size();
        size_t col = matrix[0].size();

        deque<pair<int, int>> queues;
        vector<vector<int>> visited(row, vector<int>(col , 0));

        bool isHaveOne = false;
        for (size_t i = 0; i < row; i++) {
            for (size_t j = 0; j < col; j++) {
                if (matrix[i][j]) {
                    queues.push_back({i, j});
                    isHaveOne = true;
                }
            }
        }

        if (!isHaveOne) {
            return result;
        }

        while (!queues.empty()) {
            auto content = queues.front();
            queues.pop_front();

            bool found = false;
            int level = 0;

            deque<pair<int, int>> tqueue;
            tqueue.push_back(content);

            vector<vector<int>> tvisited(visited);
            tvisited[content.first][content.second] = 1;

            while (!found && !tqueue.empty()) {
                level++;

                int queue_len = tqueue.size();
                // 保证队列中的每个数都能加上基本的平方数
                for (int i = 0; i < queue_len; i++) {
                    auto tcontent = tqueue.front();
                    tqueue.pop_front();

                    for (auto temp : layouts) {
                        int newx = tcontent.first + temp[0];
                        int newy = tcontent.second + temp[1];

                        if (newx < 0 || newy < 0 || newx >= row || newy >= col || tvisited[newx][newy]) {
                            continue;
                        }

                        if (!matrix[newx][newy]) {
                            found = true;
                            break;
                        }

                        tvisited[newx][newy] = 1;
                        tqueue.push_back({newx, newy});
                    }
                }
            }

            tvisited = visited;

            result[content.first][content.second] = level;
        }

        return result;
    }

    // 做法错误
    vector<vector<int>> updateMatrix2(vector<vector<int>>& matrix) {
        vector<vector<int>> result(matrix);
        if (matrix.size() == 0) {
            return result;
        }

        size_t row = matrix.size();
        size_t col = matrix[0].size();

        deque<pair<int, int>> queues;

        bool isHaveOne = false;
        for (size_t i = 0; i < row; i++) {
            for (size_t j = 0; j < col; j++) {
                if (matrix[i][j]) {
                    queues.push_back({i, j});
                    isHaveOne = true;
                }
            }
        }

        if (!isHaveOne) {
            return result;
        }

        vector<vector<int>> visited(row, vector<int>(col , 0));
        vector<vector<int>> tvisited(visited);
        while (!queues.empty()) {
            auto content = queues.front();
            queues.pop_front();

            int level = 0;
            bool found = false;

            DFSHelper(matrix, result, visited, level, content.first, content.second, row, col, found);

            tvisited = visited;
            //result[content.first][content.second] = level;
        }

        return result;
    }

    // 无法保证取得的路径是最短的，因为是深度递归，所以有可能找的那条路径全都是1的，所以这样使用DFS是错误的
    void DFSHelper(vector<vector<int>>& matrix, vector<vector<int>>& result, vector<vector<int>>& visited,
                   int& dis, int x, int y, int row, int col, bool& found) {
        if (found) {
            return ;
        }

        dis++;
        visited[x][y] = 1;

        if (!matrix[x][y]) {
            result[x][y] = dis;
            found = true;
            return ;
        }
        else {
            for (auto temp : layouts) {
                int newx = x + temp[0];
                int newy = y + temp[1];

                if (found) {
                    return ;
                }

                if (newx < 0 || newy < 0 || newx >= row || newy >= col || visited[newx][newy]) {
                    continue;
                }

                DFSHelper(matrix, result, visited, dis, newx, newy, row, col, found);

                if (found) {
                    return ;
                }
            }
        }
        dis--;
        visited[x][y] = 0;
    }

    /**
     * 将二维数组中为0的加入到队列中，1的则置为－1
     * 因为必然存在和1的元素相邻的元素0，所以当找到这样的周围是1的0时
     * 则把这个1的元素同样加入到队列中，因为可能会存在被1包围的1
     * 同时设置其距离，这个则需要将其值设为初始元素的值（同样是1的元素）＋1，
     * 这个时候其的值不再是-1，同时起到了纪录其已经访问过了的作用
     *
     * 可以理解为如果上一个（初始位置）如果是0，则说明其在周围，自然为1
     * 但是也会碰到被1包围的1，同样根据上面计算出来的1去计算后面的1的元素
     * 有些dp的思想
     *
     * @param matrix
     * @return
     */
    vector<vector<int>> updateMatrix3(vector<vector<int>>& matrix) {
        vector<vector<int>> result(matrix);
        if (matrix.size() == 0) {
            return result;
        }

        size_t row = matrix.size();
        size_t col = matrix[0].size();

        typedef pair<int, int> tp;

        deque<pair<int, int>> queues;
        for (size_t i = 0; i < row; i++) {
            for (size_t j = 0; j < col; j++) {
                if (matrix[i][j] == 0) {
                    queues.push_back(tp(i, j));
                }
                else {
                    result[i][j] = -1;
                }
            }
        }

        while (!queues.empty()) {
            auto content = queues.front();
            queues.pop_front();

            for (auto temp : layouts) {
                int newx = content.first + temp[0];
                int newy = content.second + temp[1];

                if (newx >= 0 && newx < row && newy >= 0 && newy < col && result[newx][newy] == -1) {
                    result[newx][newy] = result[content.first][content.second] + 1; //注意不是自增
                    queues.push_back({newx, newy});
                }
            }
        }

        return result;
    }

    // 计算层数，并将其设置为负数，作为访问过的标记
    vector<vector<int>> updateMatrix4(vector<vector<int>>& matrix) {
        if (matrix.size() == 0) {
            return matrix;
        }

        size_t row = matrix.size();
        size_t col = matrix[0].size();

        typedef pair<int, int> tp;

        deque<pair<int, int>> queues;
        for (size_t i = 0; i < row; i++) {
            for (size_t j = 0; j < col; j++) {
                if (matrix[i][j] == 0) {
                    queues.push_back(tp(i, j));
                }
            }
        }

        int dis = 0;
        while (!queues.empty()) {
            dis++;

            int queue_len = queues.size();
            // 保证队列中的每个数都能加上基本的平方数
            for (int i = 0; i < queue_len; i++) {
                auto content = queues.front();
                queues.pop_front();

                for (auto temp : layouts) {
                    int newx = content.first + temp[0];
                    int newy = content.second + temp[1];

                    if (newx >= 0 && newx < row && newy >= 0 && newy < col && matrix[newx][newy] == 1) {
                        matrix[newx][newy] = -dis; //做标记
                        queues.push_back({newx, newy});
                    }
                }
            }
        }

        for(int i = 0; i < row; ++i){
            for(int j = 0; j < col; ++j)
                if(matrix[i][j] < 0) matrix[i][j] = -matrix[i][j];
        }

        return matrix;
    }

    void test() {
        vector< vector<int>> water = {
                {0, 0, 0},
                {0, 1, 0},
                {0, 0, 0},
        };

        vector<vector<int>> result = this->updateMatrix4(water);
        for (auto i = 0; i < result.size(); i++) {
            for (auto j = 0; j < result[0].size(); j++) {
                cout << result[i][j] << ", ";
            }
            cout << endl;
        }
    }
};