运行时错误：引用绑定到“std::vector<int, std::allocator<int> >”类型的空指针 (stl_vector.h)

Question

这是 leetcode 210
从 0 到 n - 1，您总共需要学习 n 门课程。

有些课程可能有先决条件，例如，如果先决条件[i] = [ai, bi] 这意味着您必须先学习课程 bi，然后再学习课程 ai。

给定课程总数 numCourses 和先决条件对列表，返回完成所有课程所需的课程顺序。

如果有很多有效答案，请返回其中任何一个。如果不可能完成所有课程，则返回一个空数组。

输入：numCourses = 4，先决条件 = [[1,0],[2,0],[3,1],[3,2]] 输出：[0,2,1,3]

当我在下面提交此代码时，我会收到 runtime error: reference binding to null pointer of type 'std::vector<int, std::allocator<int> >' (stl_vector.h) 如果有人可以帮助我，我将不胜感激！

class Solution {
public:
    vector<int> adj[2002];
    bool vis[2002];
    vector <int> myvect;
    void dfs(int node)
    {
        if(!vis[node])
        {
          for(int i = 0; i < (int)adj[node].size(); i++)
          {
              if(!vis[adj[node][i]])
                  dfs(vis[adj[node][i]]);
          }
           myvect.push_back(node);
        }
        
        
    }
    vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites)
    {
       
        vector<int> adj[2002];
        int n = prerequisites.size();
        int m = prerequisites[0].size(); 
        if(n == 0 && m == 0)
        {
            for(int i = 0; i < numCourses; i++){
                myvect.push_back(i);
            }
            return myvect;
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
                adj[i].push_back(j);
        }
        
        for(int i = 0; i < numCourses; i++)
            dfs(i);
        return myvect;
        
        
    }
};

Answer 1

• 这里只有一个小错字：return vect 到 return myvect。

• 另一个小错误在这里：int m = n ? prerequisites[0].size() : 0;

• 修复这些错误后，算法部分工作正常，但不适用于所有测试用例，不知道如何修复。 (^_^)

class Solution {
    public:
        vector<int> adj[2002];
        bool vis[2002];
        vector <int> myvect;
        void dfs(int node) {
            if (!vis[node]) {
                for (int i = 0; i < (int)adj[node].size(); i++) {
                    if (!vis[adj[node][i]]) {
                        dfs(vis[adj[node][i]]);
                    }
                }

                myvect.push_back(node);
            }


        }
        vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) {

            vector<int> adj[2002];
            int n = prerequisites.size();
            int m = n ? prerequisites[0].size() : 0;

            if (n == 0 && m == 0) {
                for (int i = 0; i < numCourses; i++) {
                    myvect.push_back(i);
                }

                return myvect;
            }

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    adj[i].push_back(j);
                }
            }

            for (int i = 0; i < numCourses; i++) {
                dfs(i);
            }

            return myvect;


        }
};

• 除此之外，我们还可以将变量命名为更具描述性：

// The following block might slightly improve the execution time;
// Can be removed;
static const auto __optimize__ = []() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(NULL);
    std::cout.tie(NULL);
    return 0;
}();

// Most of headers are already included;
// Can be removed;
#include <cstdint>
#include <vector>

using ValueType = std::uint_fast16_t;
using Graph = std::vector<std::vector<ValueType>>;

static const struct Solution {
        static const std::vector<int> findOrder(
            const int num_courses,
            const std::vector<std::vector<int>>& prerequisites
        ) {
            const Graph graph = buildGraph(num_courses, prerequisites);
            std::vector<ValueType> indegrees = getIndegrees(graph);
            std::vector<int> orders;

            for (ValueType i = 0; i < num_courses; ++i) {
                ValueType j = 0;

                for (; j < num_courses; j++) {
                    if (!indegrees[j]) {
                        orders.emplace_back(j);
                        break;
                    }
                }

                if (j == num_courses) {
                    return {};
                }

                --indegrees[j];

                for (const auto& edge : graph[j]) {
                    --indegrees[edge];
                }
            }

            return orders;
        }

    private:
        
        static const Graph buildGraph(
            const int num_courses,
            const std::vector<std::vector<int>>& prerequisites
        ) {
            Graph graph(num_courses);

            for (const auto& prerequisite : prerequisites) {
                graph[prerequisite[1]].emplace_back(prerequisite[0]);
            }

            return graph;
        }

        static const std::vector<ValueType> getIndegrees(
            const Graph& graph
        ) {
            std::vector<ValueType> indegrees(std::size(graph), 0);

            for (const auto& adj_edges : graph) {
                for (const auto& edge : adj_edges) {
                    ++indegrees[edge];
                }
            }

            return indegrees;
        }

};