【剑指Offer】模拟

剑指 Offer 29. 顺时针打印矩阵

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

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

限制：

• 0 <= matrix.length <= 100
• 0 <= matrix[i].length <= 100

class Solution {
public:
    vector<int> ans;
    vector<vector<bool>> vis;
    vector<vector<int>> dirs = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int n, m;
    void dfs(int x, int y, vector<vector<int>>& matrix, int dir){
        ans.push_back(matrix[x][y]);
        vis[x][y] = true;
        for(int i = 0; i < 4; ++ i, dir = (dir + 1) % 4){
            int nx = x + dirs[dir][0], ny = y + dirs[dir][1];
            if(nx >= 0 && nx < n && ny >= 0 && ny < m && vis[nx][ny] == false){
                dfs(nx, ny, matrix, dir);
                return ;
            }
        }
        return ;
    }
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        ans.clear();
        if(matrix.size() == 0)return ans;
        n = matrix.size(), m = matrix[0].size();
        vis.clear();
        vis.resize(n, vector<bool>(m, false));
        dfs(0, 0, matrix, 0);
        return ans;
    }
};

算法思路

这题用的是深度优先搜索，主要是方向的确定，主要是按左->下->右->上->左...这个顺序，至于从哪开始走取决于上一步走的方向，我们只需判断原方向走可不可行，可行的话就走，不可行就换方向，直到四个方向都不能走则矩阵填充完毕。

剑指 Offer 31. 栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

示例 2：

输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。

提示：

1. 0 <= pushed.length == popped.length <= 1000
2. 0 <= pushed[i], popped[i] < 1000
3. pushed 是 popped 的排列。

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        int idxA = 0, idxB = 0;
        stack<int> stk;
        while(idxB < popped.size()){
            if(stk.empty() || stk.top() != popped[idxB]){
                if(idxA == pushed.size())break;
                stk.push(pushed[idxA]);
                idxA ++;
            }else{
                stk.pop();
                idxB ++;
            }
        }
        return idxB == popped.size();
    }
};

算法思路

这题直接模拟，用一个栈来存储，当栈顶元素等于idxB指向的popped中的元素时则栈弹出，idxB后移；否则则继续往栈中push元素。

【剑指Offer】系列：
【剑指Offer】栈
【剑指Offer】链表
【剑指Offer】字符串
【剑指Offer】查找算法
【剑指Offer】查找算法(1)
【剑指Offer】搜索与回溯算法
【剑指Offer】搜索与回溯算法(1)
【剑指Offer】动态规划
【剑指Offer】动态规划(1)
【剑指Offer】动态规划(2)
【剑指Offer】双指针
【剑指Offer】双指针(1)
【剑指Offer】双指针(2)
【剑指Offer】搜索与回溯算法(2)
【剑指Offer】搜素与回溯算法(3)
【剑指Offer】排序
【剑指Offer】排序(1)
【剑指Offer】搜索与回溯算法(4)
【剑指Offer】搜索与回溯算法(5)
【剑指Offer】分治算法
【剑指Offer】位运算
【剑指Offer】位运算(1)
【剑指Offer】数学
【剑指Offer】数学(1)