wu_hehehe 2023-12-09 15:21 采纳率: 0%
浏览 9

3346-最大通过数,python

不知道为什么错,可以帮忙看下吗

img


(正文长度有要求,正文长度有要求。正文长度有要求、正文长度有要求·)

  • 写回答

3条回答 默认 最新

  • CSDN-Ada助手 CSDN-AI 官方账号 2023-12-10 00:12
    关注

    【相关推荐】



    • 帮你找了个相似的问题, 你可以看下: https://ask.csdn.net/questions/7473990
    • 这篇博客你也可以参考下:Python-打印指定范围内的全部回文素数(高教社,《Python编程基础及应用》习题8-7) (10分) 回文素数是指一个数既是素数又是回文数,例如131既是素数又是回文数。
    • 您还可以看一下 jeevan老师的Python量化交易,大操手量化投资系列课程之内功修炼篇课程中的 讲师简介,量化交易介绍及自动化交易演示小节, 巩固相关知识点
    • 除此之外, 这篇博客: python蓝桥杯中的 这个跟上面那个竟然都是python版70分,但是用的方式不一样,可以说是不同的算法,不过我觉得这个用的字典还挺通俗易懂的,而且写得也挺少的。 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

      在这里插入图片描述
      看这一张图,其实是这样的,就是当他本身调用本身时,调用一次,就往更深的函数走,但是如果说最深的这一层走不下去了,就开始返回到上一层,并执行完上一层的下面的内容。当上一层也走到了尽头,就回到他的上一层,阻塞打开,执行完剩下的部分。原来是这样。
      这道题 最重要的就是 先储存树 然后遍历 使用递归(深度优先遍历 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")    
      

    如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

    展开全部

    评论
  • 梦幻精灵_cq 2023-12-23 03:38
    关注
    • 本题目算法逻辑不难:典型的“贪心算法”。判定比较左右当前关卡所需紫水晶数量,选择较小的过关;如果一样则任意左右。过关后关卡向前推进一关,直到消耗到紫水晶数量都小于当前关卡(左右关卡)所需。左右关卡的遍历,用“双指针”(设置left、right两个变量)很好实现。

      难点在于当左或右关卡一边关卡先过完的情况,这可以引入“无穷大”(Python中的无穷大∞是inf字符串,它是浮点型float,其使用形式为用float函数转换字符串“inf”为浮点型:float('inf'))的概念来解决。
    • 样例代码运行效果截屏图片

      img

    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")
    
    

    展开全部

    评论 编辑记录
  • DTcode7 前端领域优质创作者 2024-06-04 17:12
    关注

    答案引用自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是一个二维列表,表示网络的邻接矩阵;sourcesink分别是源节点和汇节点的索引。这个函数返回的是最大流量。

    展开全部

    评论
编辑
预览

报告相同问题?

问题事件

  • 创建了问题 12月9日

悬赏问题

  • ¥15 全志t113i启动qt应用程序提示internal error
  • ¥15 ensp可以看看嘛.
  • ¥80 51单片机C语言代码解决单片机为AT89C52是清翔单片机
  • ¥60 优博讯DT50高通安卓11系统刷完机自动进去fastboot模式
  • ¥15 minist数字识别
  • ¥15 在安装gym库的pygame时遇到问题,不知道如何解决
  • ¥20 uniapp中的webview 使用的是本地的vue页面,在模拟器上显示无法打开
  • ¥15 网上下载的3DMAX模型,不显示贴图怎么办
  • ¥15 关于#stm32#的问题:寻找一块开发版,作为智能化割草机的控制模块和树莓派主板相连,要求:最低可控制 3 个电机(两个驱动电机,1 个割草电机),其次可以与树莓派主板相连电机照片如下:
  • ¥15 Mac(标签-IDE|关键词-File) idea
手机看
程序员都在用的中文IT技术交流社区

程序员都在用的中文IT技术交流社区

专业的中文 IT 技术社区,与千万技术人共成长

专业的中文 IT 技术社区,与千万技术人共成长

关注【CSDN】视频号,行业资讯、技术分享精彩不断,直播好礼送不停!

关注【CSDN】视频号,行业资讯、技术分享精彩不断,直播好礼送不停!

客服 返回
顶部