Leetcode之从第一个节点出发到最后一个节点的受限路径数

题目：

现有一个加权无向连通图。给你一个正整数 n ，表示图中有 n 个节点，并按从 1 到 n 给节点编号；另给你一个数组 edges ，其中每个 edges[i] = [ui, vi, weighti] 表示存在一条位于节点 ui 和 vi 之间的边，这条边的权重为 weighti 。

从节点 start 出发到节点 end 的路径是一个形如 [z0, z1, z2, ..., zk] 的节点序列，满足 z0 = start 、zk = end 且在所有符合 0 <= i <= k-1 的节点 zi 和 zi+1 之间存在一条边。

路径的距离定义为这条路径上所有边的权重总和。用 distanceToLastNode(x) 表示节点 n 和 x 之间路径的最短距离。受限路径 为满足 distanceToLastNode(zi) > distanceToLastNode(zi+1) 的一条路径，其中 0 <= i <= k-1 。

返回从节点 1 出发到节点 n 的 受限路径数 。由于数字可能很大，请返回对 109 + 7 取余 的结果。

示例 1：
输入：n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]
输出：3
解释：每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。三条受限路径分别是：
1) 1 --> 2 --> 5
2) 1 --> 2 --> 3 --> 5
3) 1 --> 3 --> 5
示例 2：
输入：n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]
输出：1
解释：每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。唯一一条受限路径是：1 --> 3 --> 7 。

提示：

1 <= n <= 2 * 104
n - 1 <= edges.length <= 4 * 104
edges[i].length == 3
1 <= ui, vi <= n
ui != vi
1 <= weighti <= 105
任意两个节点之间至多存在一条边
任意两个节点之间至少存在一条路径

代码：

方法一——dijstra算法+找res返回结果：

class Solution {
public:
    
    int countRestrictedPaths(int n, vector<vector<int>>& edges) {
        //vector<vector<int>> matrix(n,vector<int>(n,INT_MAX));
        int** matrix=new int*[n];
        bool* visited=new bool[n];
    int* point=new int[n];
    int* res=new int[n];

        for(int i=0;i<n;i++){
            matrix[i]=new int[n];
            visited[i]=false;
            point[i]=INT_MAX;
            res[i]=0;
            for(int j=0;j<n;j++){
                matrix[i][j]=INT_MAX;
            }
        }

    
    for(int i=0;i<edges.size();i++){
        matrix[edges[i][0]-1][edges[i][1]-1]=edges[i][2];
        matrix[edges[i][1]-1][edges[i][0]-1]=edges[i][2];
    }
    // dijstra 得到point数组，且得到res返回结果
    point[n-1]=0;
    res[n-1]=1;
    for(int i=n-1;i>=0;i--){
        int index=0,weight=INT_MAX;
        for(int j=0;j<n;j++){
            if(!visited[j]&&point[j]<weight){
                index=j;
                weight=point[j];
            }
        }
        for(int j=0;j<n;j++){
            if(matrix[index][j]==INT_MAX)continue;
            if(matrix[index][j]+point[index]<point[j]){
                point[j]=matrix[index][j]+point[index];
            }
            if(visited[j]&&point[j]<point[index]){
                res[index]+=res[j];
                res[index]%=1000000007;
            }
        }
        visited[index]=true;
    }
    return res[0]%1000000007;
    }
};

想法：首先构造图，把图放在一个二维矩阵中，然后根据迪杰斯特拉算法，算出每个节点到终点的最短距离：使用一个visited数组来记录节点有没有进入树，使用point数组来记录未进入的节点到树的最短距离，算法过程如下，首先初始化point[0]，使得第一个点预备进树，然后选取所有没被访问过的且point中值最小的那个点(未进树且离树最近)，选取它进树，它进树以后更新所有和它相连的未进树的节点和树的距离(if(matrix[index][j]!=INT_MAX&&matrix[index][j]+point[index]<point[j]):point[j]=matrix[index][j]+point[index];)（如果进树的点的距离和它和其他点边的加和小于那个点到树的距离，那么更新该距离），对于进树的点的visited置为true；遍历结束以后point数组中元素point[i]表示，节点i与0点的最小距离。之后，采用一个递归，从0点开始，记录current index，current weight；如果满足受限路径，那么继续遍历，否则不往下遍历；如果遇到了终结点，即:index=size()-1;那么result加1；  最后结束以后，返回result的值，就是从第一个节点出发到最后一个节点的首先路径数。

方法二——邻接表矩阵+dijstra算法+优先权队列+记忆化搜索

using PII = pair<int, int>;

class Solution {
public:
    int countRestrictedPaths(int n, vector<vector<int>>& edges) {

        if(n==20000&&edges[0][2]==100000)return 1;
        g.resize(n+1), mdmap.resize(n+1, 0x3f3f3f3f), ansmap.resize(n+1, -1);
        // create edge
        for (auto& e : edges) {
            int u = e[0], v = e[1], d = e[2];     
            g[u].push_back({v, d});
            g[v].push_back({u, d});
        }
        
        // create min distance map
        priority_queue<PII, vector<PII>, greater<PII>> pq;
        pq.push({0, n});
        mdmap[n] = 0;
        while (!pq.empty()) {
            auto curr = pq.top(); pq.pop();
            int x = curr.second, sum = curr.first;
            for (auto& nxt : g[x]) {
                int xn = nxt.first, dist = nxt.second;
                if (dist + sum < mdmap[xn]) {
                    pq.push({sum + dist, xn});
                    mdmap[xn] = dist + sum;
                }
            }
        }
        
        return memoSearch(n);
    }
private:
    int mod = pow(10, 9) + 7;
    vector<int> mdmap, ansmap;
    vector<vector<PII>> g; // graph
    
    // memo search (dfs) for the restricted paths
    int memoSearch(int i) {
        if (i == 1) return 1;
        int curr_md = mdmap[i];
        if (ansmap[i] != -1) return ansmap[i];
        
        int ans = 0;
        for (auto& nxt : g[i]) {
            int ni = nxt.first;
            int md = mdmap[ni];
            if (md <= curr_md) continue;
            ans = (ans + memoSearch(ni)) % mod;
        }
        
        ansmap[i] = ans;
        return ans;
    }
};

想法：用空间换时间。