算法期中1003. 最近的0

Description
输入一个N*M的01矩阵A，对矩阵的每个位置，求至少经过多少步可以到达一个0. 每一步可以往上下左右走一格.

请为下面的Solution类实现解决这一问题的函数nearestZero，函数参数A为给出的01矩阵，A的行数和列数均不大于100. 函数的返回值是问题的答案.

class Solution {
public:
    vector<vector<int>>nearestZero(vector<vector<int>>& A)  {

    }
};

例如：
A=
1 1 1
0 1 1
0 0 1

答案为
1 2 3
0 1 2
0 0 1

注意：你只需要提交Solution类的代码，你在本地可以编写main函数测试程序，但不需要提交main函数的代码. 注意不要修改类和函数的名称.

解析：勉强使用动态规划？每一个格子中的值都取相邻格子中所有值的最小值再加1（如果原矩阵中该处值为0，则结果矩阵的值也为0）。迭代开始前，我将结果矩阵初始化为题目矩阵。
考试时，我以为迭代次数会和矩阵的长宽有关，所以总是time limited error。
考完后，室友香香的思想和我类似，她令两次迭代结果不变时就停止迭代，AC了。
我就修改了下我的代码。虽然不能再测试了，但可以明显地发现，即使原矩阵的维度很大，随机生成的话，计算结果矩阵迭代次数并不多。
应该还有许多细节可以优化的。

#include<iostream>
#include<algorithm>
#include<vector>
#include<time.h>
using namespace std;
const int rowNum = 15;
const int colNum = 15;

class Solution {
public:
    vector<vector<int>> nearestZero(vector<vector<int>>& A) {
        vector<vector<int>> res = A;  // 将结果矩阵初始化为A
        int rowNum = res.size();
        int colNum = res[0].size();

        for (int k = 0; ; k++) {
            int changed = 0;
            for (int i = 0; i < rowNum; i++) {  // 不断迭代，直到结果矩阵不再变化。
                for (int j = 0; j < colNum; j++) {
                    if (A[i][j] == 0)  // 如果该处值为0， 则结果矩阵中的值也应为0
                        res[i][j] = 0;
                    else {  // 否则就计算出四周的最小值，+1成为自己的值
                        int tmp = calValue(res, i, j);
                        if(tmp != res[i][j]) {
                            changed++;
                            res[i][j] = tmp;
                        }
                    }
                }
            }
            if (changed == 0) {
                cout << k + 1 << "times" << endl;
                break;
            }
        }
        return res;
    }
    // 计算出上下左右（如果合法的话）的点中最小的一个值，+1成为自己的值
    int calValue(vector<vector<int>> res, int i, int j) {
        int rowNum = res.size();
        int colNum = res[0].size();
        vector<int> sets;
        if ((i - 1 >= 0 && i - 1 < rowNum) && (j >= 0 && j < colNum)) {  // 上
            sets.push_back(res[i - 1][j] + 1);
        }
        if ((i >= 0 && i< rowNum) && (j + 1 >= 0 && j + 1 < colNum)) { // 右
            sets.push_back(res[i][j + 1] + 1);
        }
        if ((i + 1 >= 0 && i + 1 < rowNum) && (j >= 0 && j < colNum)) {  // 下
            sets.push_back(res[i + 1][j] + 1);
        }
        if ((i >= 0 && i< rowNum) && (j - 1 >= 0 && j - 1 < colNum)) {  // 左
            sets.push_back(res[i][j - 1] + 1);
        }
        int min = 999;
        for (int i = 0; i < sets.size(); i++) {
            if (sets[i] < min)
                min = sets[i];
        }
        return min;
    }
};


int main() {
    Solution solution;
    // A是确定的矩阵
    // test是随机生成的矩阵
    vector<vector<int>> A = { { 1, 1, 1, 1, 1},{ 0, 1, 1,  1, 1},{ 0, 0, 1, 1, 1} ,{ 0, 0, 0, 1, 1 } ,{ 0, 0, 0, 0, 1 } };
    vector<vector<int>> test(rowNum, vector<int>(colNum));
    srand((unsigned)time(NULL));

    cout << "输入矩阵" << endl;
    for (int i = 0; i < rowNum; i++) {
        for (int j = 0; j < colNum; j++) {
            test[i][j] = rand() % 2;
            cout << test[i][j] << " ";
        }
        cout << endl;
    }
    cout << "结果矩阵" << endl;
    vector<vector<int>> res = solution.nearestZero(test);
    int rowNum = res.size();
    int colNum = res[0].size();
    for (int i = 0; i < rowNum; i++) {
        for (int j = 0; j < colNum; j++) {
            cout << res[i][j] << " ";
        }
        cout << endl;
    }
    system("pause");
    return 0;
}

上述代码仍然超时，于是优化一下代码，省去了不少冗余步骤。AC。

class Solution {
public:
    vector<vector<int>> nearestZero(vector<vector<int>>& A) {
        vector<vector<int>> res(A);  // 将结果矩阵初始化为A
        vector<vector<int>> temp;  // 空的情况最好也要考虑
        if (A.size() == 0) return temp;
        int rowNum = res.size();
        int colNum = res[0].size();
        int changed = 1;
        for (int i = 0; i < rowNum; i++) {
            for (int j = 0; j < colNum; j++) {
                if (res[i][j] != 0)
                    res[i][j] = -1;
            }
        }

        while(changed != 0) {
            changed = 0;
            for (int i = 0; i < rowNum; i++) {  // 不断迭代，直到结果矩阵不再变化。
                for (int j = 0; j < colNum; j++) {
                    if (res[i][j] == 0)  // 如果该处值为0， 则结果矩阵中的值也应为0
                        continue;              // 否则就计算出四周的最小值，+1成为自己的值
                    int min = 999;
                    if (i > 0 && res[i - 1][j] != -1 && res[i - 1][j] < min) {  // 上
                        min = res[i - 1][j];
                    }
                    if (i < rowNum - 1 && res[i + 1][j] != -1 && res[i + 1][j] < min) {  // 下
                        min = res[i + 1][j];
                    }
                    if (j > 0 && res[i][j - 1] != -1 && res[i][j - 1] < min) { // 左
                        min = res[i][j - 1];
                    }
                    if (j < colNum - 1 && res[i][j + 1] != -1 && res[i][j + 1] < min) {  // 右
                        min = res[i][j + 1];
                    }
                    if (res[i][j] == -1 || res[i][j] > min + 1) { 
                        res[i][j] = min + 1;
                        changed++;
                    }
                }
            }
        }
        return res;
    }
};