[面试金典]顺时针打印矩阵

题目链接：http://www.nowcoder.com/practice/9b4c81a02cd34f76be2659fa0d54342a?rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

问题

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

则依次打印出数字：
1→2→3→4→8→12→16→15→14→13→9→5→6→7→11→10.

分析

一开始把他当做迷宫问题处理，假如碰到边界或者访问过的点，就按照→， ↓， ←， ↑的顺序依次变向，直到周围的四个方向的点都是访问过的为止。

• 边界的判断：0~size
• 访问过的点：用一个矩阵来记录
• 四个方向：{→， ↓， ←， ↑} = {{0，1}, {1，0}, {0， -1}, {-1， 0}}

然而杯具的是OJ结果是栈溢出，说白点就是我用的空间太大了。纠结蛋疼之际只能改变一下判断方法，剩下记录访问点的矩阵空间。方法就是记录访问边界

• 初始化：横纵坐标的访问方位是{横坐标， 纵坐标} = {{0， size}，{0， size}}
• 访问了第一行后：纵坐标范围缩小为{横坐标， 纵坐标} = {{0， size}，{1， size}}
• 访问了最后一列后：横坐标范围缩小为{横坐标， 纵坐标} = {{0， size - 1}，{1， size}}
• 依次循环记录…

这样用一个2*2的数据就可以代替一个矩阵了，太棒了！

小结

又学会了一项优化技能；其次是二维vector的初始化方法：

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

实现

方案一

class Solution {public:    bool check(vector <vector <bool> > m, int x, int y, int dx, int dy){        int lx = m[0].size() - 1;        int ly = m.size() - 1;        if(x + dx < 0 || x + dx > lx || y + dy < 0 || y + dy > ly){            return false;        }        if(m[x + dx][y + dy]){            return false;        }        return true;    }    vector<int> printMatrix(vector<vector<int> > matrix) {        vector <int> rv;        if(matrix.empty())            return rv;        int m = matrix.size();        int n = matrix[0].size();        vector <vector <bool> > fv(m, vector<bool>(n, false));        int dy[4] = {1, 0, -1, 0};        int dx[4] = {0, 1, 0, -1};        bool flag = true;        int i = 0, j = 0;        rv.push_back(matrix[0][0]);        fv[0][0] = true;        //int T = m * n - 1;        while(flag){            flag = false;            for(int k = 0; k < 4; k++){                while(check(fv, i, j, dx[k], dy[k])){                    flag = true;                    i += dx[k];                    j += dy[k];                    rv.push_back(matrix[i][j]);                    fv[i][j] = true;                }            }        }        return rv;    }};

方案二

class Solution {public:    bool check(int m[2][2], int x, int y, int dx, int dy){        if(x + dx < m[0][0] || x + dx > m[0][1] || y + dy < m[1][0] || y + dy > m[1][1]){            return false;        }        return true;    }    vector<int> printMatrix(vector<vector<int> > matrix) {        vector <int> rv;        if(matrix.size() == 0 || matrix[0].size() == 0)            return rv;        int max[2][2] = {{0, 0}, {0, 0}};        max[0][1] = matrix.size() - 1;        max[1][1] = matrix[0].size() - 1;        int dx[4] = {0, 1, 0, -1};        int dy[4] = {1, 0, -1, 0};        bool flag = true;        int i = 0, j = 0;        rv.push_back(matrix[0][0]);        while(flag){            flag = false;            for(int k = 0; k < 4; k++){                while(check(max, i, j, dx[k], dy[k])){                    flag = true;                    i += dx[k];                    j += dy[k];                    rv.push_back(matrix[i][j]);                }                switch (k) {                    case 0:                        max[0][0] += 1;                        break;                    case 1:                        max[1][1] -= 1;                        break;                    case 2:                        max[0][1] -= 1;                        break;                    case 3:                        max[1][0] += 1;                        break;                    default:                        break;                }            }        }        return rv;    }};

反思

迷宫问题是一个常见的问题，其思想还是很不错的。