feat: add solutions to lc problem: No.0787

No.0787.Cheapest Flights Within K Stop

solution/0700-0799/0787.Cheapest Flights Within K Stops/README.md

@@ -55,22 +55,173 @@ src = 0, dst = 2, k = 0
 
 <!-- 这里可写通用的实现逻辑 -->
 
+DFS + 记忆化搜索。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+from functools import lru_cache
+
+
+class Solution:
+    def findCheapestPrice(self, n: int, flights: List[List[int]], src: int, dst: int, k: int) -> int:
+        @lru_cache(None)
+        def dfs(u, k):
+            if u == dst:
+                return 0
+            if k <= 0:
+                return float('inf')
+            k -= 1
+            ans = float('inf')
+            for v, p in g[u]:
+                ans = min(ans, dfs(v, k) + p)
+            return ans
+
+        g = defaultdict(list)
+        for u, v, p in flights:
+            g[u].append((v, p))
+        ans = dfs(src, k + 1)
+        return -1 if ans >= float('inf') else ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int[][] memo;
+    private int[][] g;
+    private int dst;
+    private static final int INF = (int) 1e6;
+
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        n += 10;
+        memo = new int[n][n];
+        for (int i = 0; i < n; ++i) {
+            Arrays.fill(memo[i], -1);
+        }
+        g = new int[n][n];
+        for (int[] e : flights) {
+            g[e[0]][e[1]] = e[2];
+        }
+        this.dst = dst;
+        int ans = dfs(src, k + 1);
+        return ans >= INF ? -1 : ans;
+    }
+
+    private int dfs(int u, int k) {
+        if (memo[u][k] != -1) {
+            return memo[u][k];
+        }
+        if (u == dst) {
+            return 0;
+        }
+        if (k <= 0) {
+            return INF;
+        }
+        int ans = INF;
+        for (int v = 0; v < g[u].length; ++v) {
+            if (g[u][v] > 0) {
+                ans = Math.min(ans, dfs(v, k - 1) + g[u][v]);
+            }
+        }
+        memo[u][k] = ans;
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> memo;
+    vector<vector<int>> g;
+    int dst;
+    int inf = 1e6;
+
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
+        n += 10;
+        memo.resize(n, vector<int>(n, -1));
+        g.resize(n, vector<int>(n));
+        for (auto& e : flights) g[e[0]][e[1]] = e[2];
+        this->dst = dst;
+        int ans = dfs(src, k + 1);
+        return ans >= inf ? -1 : ans;
+    }
+
+    int dfs(int u, int k) {
+        if (memo[u][k] != -1) return memo[u][k];
+        if (u == dst) return 0;
+        if (k <= 0) return inf;
+        int ans = inf;
+        for (int v = 0; v < g[u].size(); ++v)
+            if (g[u][v] > 0)
+                ans = min(ans, dfs(v, k - 1) + g[u][v]);
+        memo[u][k] = ans;
+        return memo[u][k];
+    }
+};
+```
 
+### **Go**
+
+```go
+func findCheapestPrice(n int, flights [][]int, src int, dst int, k int) int {
+	n += 10
+	memo := make([][]int, n)
+	g := make([][]int, n)
+	for i := range memo {
+		memo[i] = make([]int, n)
+		g[i] = make([]int, n)
+		for j := range memo[i] {
+			memo[i][j] = -1
+		}
+	}
+
+	for _, e := range flights {
+		g[e[0]][e[1]] = e[2]
+	}
+	inf := int(1e6)
+	var dfs func(u, k int) int
+	dfs = func(u, k int) int {
+		if memo[u][k] != -1 {
+			return memo[u][k]
+		}
+		if u == dst {
+			return 0
+		}
+		if k <= 0 {
+			return inf
+		}
+		ans := inf
+		for v, p := range g[u] {
+			if p > 0 {
+				ans = min(ans, dfs(v, k-1)+p)
+			}
+		}
+		memo[u][k] = ans
+		return ans
+	}
+	ans := dfs(src, k+1)
+	if ans >= inf {
+		return -1
+	}
+	return ans
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0700-0799/0787.Cheapest Flights Within K Stops/README_EN.md

@@ -52,13 +52,162 @@ The cheapest price from city <code>0</code> to city <code>2</code> with at most
 ### **Python3**
 
 ```python
-
+from functools import lru_cache
+
+
+class Solution:
+    def findCheapestPrice(self, n: int, flights: List[List[int]], src: int, dst: int, k: int) -> int:
+        @lru_cache(None)
+        def dfs(u, k):
+            if u == dst:
+                return 0
+            if k <= 0:
+                return float('inf')
+            k -= 1
+            ans = float('inf')
+            for v, p in g[u]:
+                ans = min(ans, dfs(v, k) + p)
+            return ans
+
+        g = defaultdict(list)
+        for u, v, p in flights:
+            g[u].append((v, p))
+        ans = dfs(src, k + 1)
+        return -1 if ans >= float('inf') else ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    private int[][] memo;
+    private int[][] g;
+    private int dst;
+    private static final int INF = (int) 1e6;
+
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        n += 10;
+        memo = new int[n][n];
+        for (int i = 0; i < n; ++i) {
+            Arrays.fill(memo[i], -1);
+        }
+        g = new int[n][n];
+        for (int[] e : flights) {
+            g[e[0]][e[1]] = e[2];
+        }
+        this.dst = dst;
+        int ans = dfs(src, k + 1);
+        return ans >= INF ? -1 : ans;
+    }
+
+    private int dfs(int u, int k) {
+        if (memo[u][k] != -1) {
+            return memo[u][k];
+        }
+        if (u == dst) {
+            return 0;
+        }
+        if (k <= 0) {
+            return INF;
+        }
+        int ans = INF;
+        for (int v = 0; v < g[u].length; ++v) {
+            if (g[u][v] > 0) {
+                ans = Math.min(ans, dfs(v, k - 1) + g[u][v]);
+            }
+        }
+        memo[u][k] = ans;
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> memo;
+    vector<vector<int>> g;
+    int dst;
+    int inf = 1e6;
+
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
+        n += 10;
+        memo.resize(n, vector<int>(n, -1));
+        g.resize(n, vector<int>(n));
+        for (auto& e : flights) g[e[0]][e[1]] = e[2];
+        this->dst = dst;
+        int ans = dfs(src, k + 1);
+        return ans >= inf ? -1 : ans;
+    }
+
+    int dfs(int u, int k) {
+        if (memo[u][k] != -1) return memo[u][k];
+        if (u == dst) return 0;
+        if (k <= 0) return inf;
+        int ans = inf;
+        for (int v = 0; v < g[u].size(); ++v)
+            if (g[u][v] > 0)
+                ans = min(ans, dfs(v, k - 1) + g[u][v]);
+        memo[u][k] = ans;
+        return memo[u][k];
+    }
+};
+```
 
+### **Go**
+
+```go
+func findCheapestPrice(n int, flights [][]int, src int, dst int, k int) int {
+	n += 10
+	memo := make([][]int, n)
+	g := make([][]int, n)
+	for i := range memo {
+		memo[i] = make([]int, n)
+		g[i] = make([]int, n)
+		for j := range memo[i] {
+			memo[i][j] = -1
+		}
+	}
+
+	for _, e := range flights {
+		g[e[0]][e[1]] = e[2]
+	}
+	inf := int(1e6)
+	var dfs func(u, k int) int
+	dfs = func(u, k int) int {
+		if memo[u][k] != -1 {
+			return memo[u][k]
+		}
+		if u == dst {
+			return 0
+		}
+		if k <= 0 {
+			return inf
+		}
+		ans := inf
+		for v, p := range g[u] {
+			if p > 0 {
+				ans = min(ans, dfs(v, k-1)+p)
+			}
+		}
+		memo[u][k] = ans
+		return ans
+	}
+	ans := dfs(src, k+1)
+	if ans >= inf {
+		return -1
+	}
+	return ans
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/0700-0799/0787.Cheapest Flights Within K Stops/Solution.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<vector<int>> memo;
+    vector<vector<int>> g;
+    int dst;
+    int inf = 1e6;
+
+    int findCheapestPrice(int n, vector<vector<int>>& flights, int src, int dst, int k) {
+        n += 10;
+        memo.resize(n, vector<int>(n, -1));
+        g.resize(n, vector<int>(n));
+        for (auto& e : flights) g[e[0]][e[1]] = e[2];
+        this->dst = dst;
+        int ans = dfs(src, k + 1);
+        return ans >= inf ? -1 : ans;
+    }
+
+    int dfs(int u, int k) {
+        if (memo[u][k] != -1) return memo[u][k];
+        if (u == dst) return 0;
+        if (k <= 0) return inf;
+        int ans = inf;
+        for (int v = 0; v < g[u].size(); ++v)
+            if (g[u][v] > 0)
+                ans = min(ans, dfs(v, k - 1) + g[u][v]);
+        memo[u][k] = ans;
+        return memo[u][k];
+    }
+};