feat: add solutions to lc problem: No.1786

No.1786.Number of Restricted Paths From First to Last Node

Author: yanglbme

solution/1700-1799/1786.Number of Restricted Paths From First to Last Node/README.md

@@ -53,22 +53,239 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：堆优化 Dijkstra + 记忆化搜索**
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def countRestrictedPaths(self, n: int, edges: List[List[int]]) -> int:
+        @cache
+        def dfs(i):
+            if i == n:
+                return 1
+            ans = 0
+            for j, _ in g[i]:
+                if dist[i] > dist[j]:
+                    ans = (ans + dfs(j)) % mod
+            return ans
 
+        g = defaultdict(list)
+        for u, v, w in edges:
+            g[u].append((v, w))
+            g[v].append((u, w))
+        q = [(0, n)]
+        dist = [inf] * (n + 1)
+        dist[n] = 0
+        mod = 10**9 + 7
+        while q:
+            _, u = heappop(q)
+            for v, w in g[u]:
+                if dist[v] > dist[u] + w:
+                    dist[v] = dist[u] + w
+                    heappush(q, (dist[v], v))
+        return dfs(1)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private static final int INF = Integer.MAX_VALUE;
+    private static final int MOD = (int) 1e9 + 7;
+    private List<int[]>[] g;
+    private int[] dist;
+    private int[] f;
+    private int n;
+
+    public int countRestrictedPaths(int n, int[][] edges) {
+        this.n = n;
+        g = new List[n + 1];
+        for (int i = 0; i < g.length; ++i) {
+            g[i] = new ArrayList<>();
+        }
+        for (int[] e : edges) {
+            int u = e[0], v = e[1], w = e[2];
+            g[u].add(new int[]{v, w});
+            g[v].add(new int[]{u, w});
+        }
+        PriorityQueue<int[]> q = new PriorityQueue<>((a, b) -> a[0] - b[0]);
+        q.offer(new int[]{0, n});
+        dist = new int[n + 1];
+        f = new int[n + 1];
+        Arrays.fill(dist, INF);
+        Arrays.fill(f, -1);
+        dist[n] = 0;
+        while (!q.isEmpty()) {
+            int[] p = q.poll();
+            int u = p[1];
+            for (int[] ne : g[u]) {
+                int v = ne[0], w = ne[1];
+                if (dist[v] > dist[u] + w) {
+                    dist[v] = dist[u] + w;
+                    q.offer(new int[]{dist[v], v});
+                }
+            }
+        }
+        return dfs(1);
+    }
+
+    private int dfs(int i) {
+        if (f[i] != -1) {
+            return f[i];
+        }
+        if (i == n) {
+            return 1;
+        }
+        int ans = 0;
+        for (int[] ne : g[i]) {
+            int j = ne[0];
+            if (dist[i] > dist[j]) {
+                ans = (ans + dfs(j)) % MOD;
+            }
+        }
+        f[i] = ans;
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+using pii = pair<int, int>;
+
+class Solution {
+public:
+    const int inf = INT_MAX;
+    const int mod = 1e9 + 7;
+    vector<vector<pii>> g;
+    vector<int> dist;
+    vector<int> f;
+    int n;
+
+    int countRestrictedPaths(int n, vector<vector<int>>& edges) {
+        this->n = n;
+        g.resize(n + 1);
+        dist.assign(n + 1, inf);
+        f.assign(n + 1, -1);
+        dist[n] = 0;
+        for (auto& e : edges)
+        {
+            int u = e[0], v = e[1], w = e[2];
+            g[u].emplace_back(v, w);
+            g[v].emplace_back(u, w);
+        }
+        priority_queue<pii, vector<pii>, greater<pii>> q;
+        q.emplace(0, n);
+        while (!q.empty())
+        {
+            auto [_, u] = q.top();
+            q.pop();
+            for (auto [v, w] : g[u])
+            {
+                if (dist[v] > dist[u] + w)
+                {
+                    dist[v] = dist[u] + w;
+                    q.emplace(dist[v], v);
+                }
+            }
+        }
+        return dfs(1);
+    }
+
+    int dfs(int i) {
+        if (f[i] != -1) return f[i];
+        if (i == n) return 1;
+        int ans = 0;
+        for (auto [j, _] : g[i])
+        {
+            if (dist[i] > dist[j])
+            {
+                ans = (ans + dfs(j)) % mod;
+            }
+        }
+        f[i] = ans;
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+const inf = math.MaxInt32
+const mod = 1e9 + 7
+
+type pair struct {
+	first  int
+	second int
+}
+
+var _ heap.Interface = (*pairs)(nil)
+
+type pairs []pair
+
+func (a pairs) Len() int { return len(a) }
+func (a pairs) Less(i int, j int) bool {
+	return a[i].first < a[j].first || a[i].first == a[j].first && a[i].second < a[j].second
+}
+func (a pairs) Swap(i int, j int)   { a[i], a[j] = a[j], a[i] }
+func (a *pairs) Push(x interface{}) { *a = append(*a, x.(pair)) }
+func (a *pairs) Pop() interface{}   { l := len(*a); t := (*a)[l-1]; *a = (*a)[:l-1]; return t }
 
+func countRestrictedPaths(n int, edges [][]int) int {
+	g := make([]pairs, n+1)
+	for _, e := range edges {
+		u, v, w := e[0], e[1], e[2]
+		g[u] = append(g[u], pair{v, w})
+		g[v] = append(g[v], pair{u, w})
+	}
+	dist := make([]int, n+1)
+	f := make([]int, n+1)
+	for i := range dist {
+		dist[i] = inf
+		f[i] = -1
+	}
+	dist[n] = 0
+	h := make(pairs, 0)
+	heap.Push(&h, pair{0, n})
+	for len(h) > 0 {
+		u := heap.Pop(&h).(pair).second
+		for _, ne := range g[u] {
+			v, w := ne.first, ne.second
+			if dist[v] > dist[u]+w {
+				dist[v] = dist[u] + w
+				heap.Push(&h, pair{dist[v], v})
+			}
+		}
+	}
+	var dfs func(int) int
+	dfs = func(i int) int {
+		if f[i] != -1 {
+			return f[i]
+		}
+		if i == n {
+			return 1
+		}
+		ans := 0
+		for _, ne := range g[i] {
+			j := ne.first
+			if dist[i] > dist[j] {
+				ans = (ans + dfs(j)) % mod
+			}
+		}
+		f[i] = ans
+		return ans
+	}
+	return dfs(1)
+}
 ```
 
 ### **...**