面试题 矩阵遍历构造

1. 斜线

输入矩阵的行数n，列数m，按照下面的规律去构造矩阵。

5 4
01 02 06 07
03 05 08 14
04 09 13 15
10 12 16 19
11 17 18 20
----------
4 5
01 02 06 07 14
03 05 08 13 15
04 09 12 16 19
10 11 17 18 20
----------
1 8
1 2 3 4 5 6 7 8
----------
8 1
1
2
3
4
5
6
7
8
----------
3 3
1 2 6
3 5 7
4 8 9
----------
5 12
01 02 06 07 15 16 25 26 35 36 45 46
03 05 08 14 17 24 27 34 37 44 47 54
04 09 13 18 23 28 33 38 43 48 53 55
10 12 19 22 29 32 39 42 49 52 56 59
11 20 21 30 31 40 41 50 51 57 58 60
----------

我的思路是设置两种方向对应两种斜线方向。

在for的过程中，推算下一个位置。每次遇到越过边界的情况，就特殊处理下一个点的位置，并且翻转方向。

这样做的特性在于，每次转向都是和边界有关，并且矩阵四边每次被越界的修正情况是固定的，分四类讨论即可。

void solve(int kaseId = -1) {
    int n, m;
    cin >> n >> m;

    pii rev_d{-1, 1};
    pii d{1, -1};

    int sz = n * m;

    vector<vector<int>> a(n, vector<int>(m, 0));

    for (int i = 1, r = 0, c = 0; i <= sz; ++i) {
        a[r][c] = i;
        int dc = c + d.first;
        int dr = r + d.second;

        if (dr < 0 || dc < 0 || dr >= n || dc >= m) {
            swap(d, rev_d);
            if (dc < 0) dc = 0;
            if (dr < 0) dr = 0;
            if (dc >= m) dc = m - 1, dr = r + 1;
            if (dr >= n) dr = n - 1, dc = c + 1;
        }
        c = dc;
        r = dr;
    }

    cout << n << " " << m << endl;
    for (const auto &ai: a) {
        for (const auto &aij : ai) {
            cout << fixed
                 << setw(to_string(sz).length())
                 << setfill('0')
                 << aij
                 << " \n"[&aij == &ai.back()];
        }
    }
}

2 绕圈

LeetCode 54. 螺旋矩阵

这题是按如上顺序遍历，其实也差不多。

由于题目特性是转向必定是向右转，所以编码上可以更tricky一点。把方向映射写成一个map，这个映射代表了如果当前方向走不通，下一个方向应该是什么。

然后只需要在遍历的过程中检查是否下一个位置走不通即可。

这种map挺实用的，可以省略很多if-else代码。

class Solution {
public:
    const map<pair<int, int>, pair<int, int>> next_dir = {
        {{0, 1}, {1, 0}},
        {{1, 0}, {0, -1}},
        {{0, -1}, {-1, 0}},
        {{-1, 0}, {0, 1}}
    };

    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int row = matrix.size();
        int col = matrix.front().size();
        int total = row * col;
        
        vector<int> ret;

        pair<int, int> d = {0, 1};
        for (int i = 1, r = 0, c = 0; i <= total; ++i) 
        {
            ret.emplace_back(matrix[r][c]);
            matrix[r][c] = 0;
            int dr = r + d.first;
            int dc = c + d.second;

            if (dr < 0 || dc < 0 || dr >= row || dc >= col || matrix[dr][dc] == 0) 
            {
                d = next_dir.at(d);
                dr = r + d.first;
                dc = c + d.second;
            }

            r = dr;
            c = dc;
        }
        
        return ret;
    }
    
};