Leetcode LCP 07. 传递信息 (图论基础问题DFS/BFS）

注意，这里由于信息是当向的，因此没有环，所以可以直接DFS。

class Solution {
public:
    int numWays(int n, vector<vector<int>>& relation, int k) {
        vector<vector<int>> edges(n);
        for (auto edge : relation) {
            int a = edge[0], b = edge[1];
            edges[a].push_back(b);
        }
        int res = 0;
        function<void(int, int)> dfs = [&](int index, int steps) {
            if(steps == k) {
                if (index == n - 1) {
                    res++;
                }
                return;
            }
            for(auto v : edges[index]) {
                dfs(v, steps + 1);
            }
        };
        dfs(0, 0);
        return res;
    }
};

BFS思路比较直接，便利k圈，然后在第k圈的时候计数。

class Solution {
public:
    int numWays(int n, vector<vector<int>> &relation, int k) {
        vector<vector<int>> edges(n);
        for (auto &edge : relation) {
            int src = edge[0], dst = edge[1];
            edges[src].push_back(dst);
        }

        int steps = 0;
        queue<int> que;
        que.push(0);
        while (!que.empty() && steps < k) {
            steps++;
            int size = que.size();
            for (int i = 0; i < size; i++) {
                int index = que.front();
                que.pop();
                for (auto &nextIndex : edges[index]) {
                    que.push(nextIndex);
                }
            }
        }

        int ways = 0;
        if (steps == k) {
            while (!que.empty()) {
                if (que.front() == n - 1) {
                    ways++;
                }
                que.pop();
            }
        }
        return ways;
    }
};

实际上直接用动态规划递推即可以解决

拓展思路：临接矩阵的矩阵乘法的含义