diff --git a/problems/kamacoder/0095.城市间货物运输II.md b/problems/kamacoder/0095.城市间货物运输II.md
index 0e8aac11..a3896b88 100644
--- a/problems/kamacoder/0095.城市间货物运输II.md
+++ b/problems/kamacoder/0095.城市间货物运输II.md
@@ -333,6 +333,8 @@ public class Main {
 
 ### Python
 
+Bellman-Ford方法求解含有负回路的最短路问题
+
 ```python 
 import sys
 
@@ -388,6 +390,52 @@ if __name__ == "__main__":
 
 ```
 
+SPFA方法求解含有负回路的最短路问题
+
+```python
+from collections import deque
+from math import inf
+
+def main():
+    n, m = [int(i) for i in input().split()]
+    graph = [[] for _ in range(n+1)]
+    min_dist = [inf for _ in range(n+1)]
+    count = [0 for _ in range(n+1)]  # 记录节点加入队列的次数
+    for _ in range(m):
+        s, t, v = [int(i) for i in input().split()]
+        graph[s].append([t, v])
+        
+    min_dist[1] = 0  # 初始化
+    count[1] = 1
+    d = deque([1])
+    flag = False
+    
+    while d:  # 主循环
+        cur_node = d.popleft()
+        for next_node, val in graph[cur_node]:
+            if min_dist[next_node] > min_dist[cur_node] + val:
+                min_dist[next_node] = min_dist[cur_node] + val
+                count[next_node] += 1
+                if next_node not in d:
+                    d.append(next_node)
+                if count[next_node] == n:  # 如果某个点松弛了n次，说明有负回路
+                    flag = True
+        if flag:
+            break
+            
+    if flag:
+        print("circle")
+    else:
+        if min_dist[-1] == inf:
+            print("unconnected")
+        else:
+            print(min_dist[-1])
+
+
+if __name__ == "__main__":
+    main()
+```
+
 ### Go
 
 ### Rust
diff --git a/problems/kamacoder/0096.城市间货物运输III.md b/problems/kamacoder/0096.城市间货物运输III.md
index 08fd010c..0e13846d 100644
--- a/problems/kamacoder/0096.城市间货物运输III.md
+++ b/problems/kamacoder/0096.城市间货物运输III.md
@@ -822,6 +822,9 @@ public class SPFAForSSSP {
 
 
 ### Python
+
+Bellman-Ford方法求解单源有限最短路
+
 ```python
 def main():
     # 輸入
@@ -855,6 +858,48 @@ def main():
             
             
 
+if __name__ == "__main__":
+    main()
+```
+
+SPFA方法求解单源有限最短路
+
+```python
+from collections import deque
+from math import inf
+
+
+def main():
+    n, m = [int(i) for i in input().split()]
+    graph = [[] for _ in range(n+1)]
+    for _ in range(m):
+        v1, v2, val = [int(i) for i in input().split()]
+        graph[v1].append([v2, val])
+    src, dst, k = [int(i) for i in input().split()]
+    min_dist = [inf for _ in range(n+1)]
+    min_dist[src] = 0  # 初始化起点的距离
+    que = deque([src])
+
+    while k != -1 and que:
+        visited = [False for _ in range(n+1)]  # 用于保证每次松弛时一个节点最多加入队列一次
+        que_size = len(que)
+        temp_dist = min_dist.copy()  # 用于记录上一次遍历的结果
+        for _ in range(que_size):
+            cur_node = que.popleft()
+            for next_node, val in graph[cur_node]:
+                if min_dist[next_node] > temp_dist[cur_node] + val:
+                    min_dist[next_node] = temp_dist[cur_node] + val
+                    if not visited[next_node]:
+                        que.append(next_node)
+                        visited[next_node] = True
+        k -= 1
+
+    if min_dist[dst] == inf:
+        print("unreachable")
+    else:
+        print(min_dist[dst])
+
+
 if __name__ == "__main__":
     main()
 ```