不知道为什么错,可以帮忙看下吗
(正文长度有要求,正文长度有要求。正文长度有要求、正文长度有要求·)
【相关推荐】
看这一张图,其实是这样的,就是当他本身调用本身时,调用一次,就往更深的函数走,但是如果说最深的这一层走不下去了,就开始返回到上一层,并执行完上一层的下面的内容。当上一层也走到了尽头,就回到他的上一层,阻塞打开,执行完剩下的部分。原来是这样。
这道题 最重要的就是 先储存树 然后遍历 使用递归(深度优先遍历 dfs)
#递归 深度搜索真的就很难理解
def dfs(node,pre):
global value,table
for i in table.get(node):
print(i,node,"..1..")
if i !=pre:
print(i,node,"..2..")
dfs(i,node)
print(i,node,"..3..")
value[node][0]+=max(value[i][0],value[i][1])
value[node][1]+=value[i][0]
print('value["%d"][0]="%d"'%(node,value[node][0]))
print('value["%d"][1]="%d"'%(node,value[node][1]))
global value, table
n = int(input())
value = list(map(int, input().split()))
value = list(map(lambda x:[0,x],value))
print(value)
value.insert(0,0)
print(value)
table = {}
for i in range(n):
table.update({i + 1: []})
print(table)
#get(键值)
for i in range(n - 1):
father, child = list(map(int, input().split()))
table.get(father).append(child)
table.get(child).append(father)
print(table)
#以上就是树的储存
dfs(1,0)
print(max(value[1][0],value[1][1]))
哎呀 这道题是真的很难,但是我还是学到了很多,这就是python的优点,他有列表可以嵌套,还有字典,可以用来储存树,好的。
我今天好像与理解了更深一点,就是递归,其实。
k=int(input())
if k>=90:
print("A")
if 90>k>=80:
print("B")
if 80>k>=70:
print("C")
if 70>k>=60:
print("D")
if k<60:
print("E")
python代码
#!/sur/bin/nve python
# coding: utf-8
def max_passages(n, m, k, a, b):
count = ai = bi = 0 # 变量初始值。
print(f"\n{' 最大过关数 ':=^35}\n\n【初始状态】\nLeft关卡数{n}: {str(a)[1:-1]}\nRight关卡数{m}: {str(b)[1:-1]}\n紫水晶: {k}\n\n已过关卡:")
while k >= 0:
if ai < n:
left = a[ai]
else:
left = float('inf') # 左关卡过完,设置左关卡当前需紫水晶数量为无穷大。
if bi < m:
right = b[bi]
else:
right = float('inf') # 右关卡过完,设置右关卡当前需紫水晶数量为无穷大。
print(f"【第{count+1:>02}关状态】Left: {left if left != float('inf') else '∞'}, Right: {right if right != float('inf') else '∞'}, 紫水晶: {k}")
if left == right:
if left <= k and ai < n:
count += 1 # 已过关卡数累加。
k -= left # 更新紫水晶数量。
ai += 1 # 左前进一关。
if right <= k and bi < m:
count += 1 # 已过关卡数累加。
k -= left # 更新紫水晶数量。
bi += 1 # 右前进一关。
else:
if left < right and k >= left and ai < n:
count += 1 # 已过关卡数累加。
k -= left # 更新紫水晶数量。
ai += 1 # 左前进一关。
elif k >= right and bi < m:
count += 1 # 已过关卡数累加。
k -= right # 更新紫水晶数量。
bi += 1 # 右前进一关。
if k <= left and k <= right:
break
print(f"\n【第{count+1:>02}关状态】Left: {a[ai] if left != float('inf') else '∞'}, Right: {b[bi] if right != float('inf') else '∞'}, 紫水晶: {k}")
return count
# 示例
n = 5 # 左边入口的关卡数。
m = 4 # 右边入口的关卡数。
k = 10 # 总共携带的紫水晶数量。
a = [1, 2, 3, 4, 5] # 左边入口每个关卡需要的紫水晶数量。
b = [1, 2, 3, 4] # 右边入口每个关卡需要的紫水晶数量。
print(f"\n\n{f' 最大过关数:{max_passages(n, m, k, a, b)} ':=^35}\n\n")
print(f"\n\n{f' 最大过关数:{max_passages(2, 2, 10, (1, 2), [3, 5])} ':=^35}\n\n")
答案引用自chatgpt生成,望对题主有所帮助/启发;若有帮助,还望采纳!
问题:3346-最大通过数,python。
这个问题可能是在询问如何在Python中实现一个算法,该算法可以计算出在一个给定的网络中,最多有多少个节点可以通过直接或间接的连接到达另一个特定的节点。这是一个经典的图论问题,通常被称为“最大流”或“最大通量”问题。
解决这个问题的一种常见方法是使用Ford-Fulkerson算法。这个算法的基本思想是找到一个增广路径(即一条从源节点到汇节点的路径,路径上的所有边的容量都未被充分利用),然后增加这条路径上的流量,直到找不到增广路径为止。
以下是一个简单的Python实现:
def max_flow(graph, source, sink):
# 初始化流量矩阵
flow = [[0 for _ in range(len(graph))] for _ in range(len(graph))]
# 定义BFS函数,用于寻找增广路径
def bfs(rGraph, s, t, parent):
visited = [False]*(len(rGraph))
queue = []
queue.append(s)
visited[s] = True
while queue:
u = queue.pop(0)
for ind, val in enumerate(rGraph[u]):
if visited[ind] == False and val > 0:
queue.append(ind)
visited[ind] = True
parent[ind] = u
if ind == t:
return True
return False
parent = [-1]*(len(graph))
max_flow = 0
while bfs(graph, source, sink, parent):
path_flow = float("Inf")
s = sink
while(s != source):
path_flow = min(path_flow, graph[parent[s]][s])
s = parent[s]
max_flow += path_flow
v = sink
while(v != source):
u = parent[v]
graph[u][v] -= path_flow
graph[v][u] += path_flow
v = parent[v]
return max_flow
在这个代码中,graph
是一个二维列表,表示网络的邻接矩阵;source
和sink
分别是源节点和汇节点的索引。这个函数返回的是最大流量。