拓扑排序+优先队列

到达目的地的方案数

class Solution {
public:
    static const int MOD = 1E9 + 7;
    using PII = pair<int,int>;
    using PLI = pair<long long, int>;
    int countPaths(int n, vector<vector<int>>& roads) {
        vector<vector<PII>> g(n);
        vector<long long> d(n,LONG_LONG_MAX);
        vector<bool> v(n,false);
        vector<int> f(n,0);
        for(auto& road:roads){
            g[road[0]].push_back(make_pair(road[1],road[2]));
            g[road[1]].push_back(make_pair(road[0],road[2]));
        }
        //对应的是一个小堆，根据距离长度进行排序
        priority_queue<PLI,vector<PLI>,greater<PLI>> q;
        // 对应的是insert
        q.emplace(0,0);
        f[0]=1;
        d[0]=0;
        while(q.size()){
            int x=q.top().second;
            q.pop();
            if(v[x])
                continue;
            v[x]=true;
            for(auto &[y,z]:g[x]){
                if(d[y]>d[x]+z){//距离更短就取代
                    d[y]=d[x]+z;
                    f[y]=f[x];
                    q.emplace(d[y],y);
                }else if(d[y]==d[x]+z){//距离相同就做加法
                    f[y]=(f[y]+f[x])%MOD;
                }
            }
        }
        return f[n-1];
    }
};

课程表4

class Solution {
public:
    vector<bool> checkIfPrerequisite(int numCourses, vector<vector<int>>& prerequisites, vector<vector<int>>& queries) {
        vector<vector<bool>> graph(numCourses,vector<bool>(numCourses,false));
        for(auto& p:prerequisites){
            graph[p[0]][p[1]]=true;
        }
        
        //floyd算法
        for(int k=0;k<numCourses;k++){
            for(int i=0;i<numCourses;i++){
                for(int j=0;j<numCourses;j++){
                    if(graph[i][j]) 
                        continue;
                    if(graph[i][k]&&graph[k][j]){
                        graph[i][j]=true;
                    }
                }
            }
        }
        vector<bool> res;
        for(auto &q:queries){
            res.push_back(graph[q[0]][q[1]]);
        }
        return res;
    }
};