sicily exercises

1.1题目描述

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

1.2思路分析

这是一道典型的采用广度优先搜索算法的题目：先将矩阵A中值为0的坐标{i, j}放入队列中，且赋值输出矩阵final[i][j]=0，再将该坐标的上、下、左、右其他四个坐标{m, n}加入队列中（坐标需要在矩阵的合理范围内），且赋值输出矩阵final[m][n]+=1，再依次取出队列中的元素直至队列为空。

1.3代码实现

class Solution {
public:
    vector<vector<int>> nearestZero(vector<vector<int>>& A) {
      int rowSize = A.size();
      if (rowSize == 0) return A;
      int colSize = A[0].size();
      vector<vector<int>> final;
      final.resize(rowSize);
      for (int i = 0; i < rowSize; i++) {
        final[i].resize(colSize);
      }

      queue<pair<int, int>> q;
      int pos[4][2] = {{0,-1},{0,1},{1,0},{-1,0}};
      for (int i = 0; i < rowSize; i++) {
        for (int j = 0; j < colSize; j++) {
            if (A[i][j] == 0) {
                final[i][j] = 0;
                q.push({i, j});
            }
        }
      }
     while (!q.empty()) {
        pair<int, int> temp = q.front();
        q.pop();
        for (int s = 0; s < 4; s++) {
            int mRow = temp.first + pos[s][0];
            int mCol = temp.second + pos[s][1];
            if (mRow >= 0 && mRow <= rowSize-1 && mCol >= 0 && mCol <= colSize-1) {
                if (final[mRow][mCol] > final[temp.first][temp.second]+1) {
                    final[mRow][mCol] = final[temp.first][temp.second]+1;
                    q.push({mRow, mCol});
                }
            }
        }
    }
    return final;
    }
};

2.1题目描述

在图论中，拓扑序（Topological Sorting）是一个有向无环图（DAG, Directed Acyclic Graph）的所有顶点的线性序列. 且该序列必须满足下面两个条件：
1. 每个顶点出现且只出现一次.
2. 若存在一条从顶点 A 到顶点 B 的路径，那么在序列中顶点 A 出现在顶点 B 的前面.
对于一个含有n个节点的有向无环图（节点编号0到n-1），输出它的一个拓扑序.
图的节点数和边数均不多于100000，保证输入的图是一个无环图.

2.2思路分析

要输出一个拓扑序，可采用基于入度的拓扑排序Kahn算法，步骤如下：
1. 计算出图中所有顶点的入度
2. 将所有入度为0的顶点加入到队列queue中；
3. 依次取出队列的头顶点，并将该顶点的相邻顶点入度减少1，如果此时入度为0则加入队列中；
4. 重复步骤3直至队列为空；

2.3代码实现

class Solution {
public:
    vector<int> topologicalSort(int n, vector<pair<int, int> >& edges) {
        vector<int> result;   //拓扑序
        vector<int> degree(n, 0);   //图中节点的入度
        queue<int> queue;   //放入入度为0的节点
        vector<vector<int> > edge(n);    //相连的边

        //更新入度和邻接表
        for (int i = 0; i < edges.size(); i++) {
            degree[edges[i].second]++;
            edge[edges[i].first].push_back(edges[i].second);
        }
        for (int i = 0; i < n; i++) {
            if (degree[i] == 0) {
                queue.push(i);
            }
        }
        while (!queue.empty()) {
            int temp = queue.front();
            queue.pop();
            result.push_back(temp);
            for (int i = 0; i < edge[temp].size(); i++) {
                degree[edge[temp][i]] -= 1;
                if (degree[edge[temp][i]] == 0) {
                    queue.push(edge[temp][i]);
                }
            }
        }
        return result;
    }
};