python蓝桥杯

对，学习要从一而终，啥都会一点点，那是没用的，总有人在这方面比你更全面，还是择一门编程语言从一而终，我决定选择python。哈哈哈哈。

真题

最短路

def dfs(node,zz):
    global lc
    if node!=zz:
        dfs(li[node-1].z,zz)
        lc+=li[node-1].mile
    
        
        
class Rode:
    #起点和终点，路径长度
    def __init__(self,qi=0,z=0,mile=0):
        self.qi=qi
        self.z=z
        self.mile=mile
n,m=map(int,input().split())
li=list()
for i in range(m):
    a,b,c=map(int,input().split())
    add_node=Rode(a,b,c)
    li.append(add_node)
                    
lc=0
for i in range(2,n+1):
    dfs(1,i)
    print(lc)
    lc=0
 我知道这个题目还有很多没有考虑到，而且这个类的结构就适合，只有唯一情况的这种，你看就是 那个二叉树 他的左和右一定是定好的了，而这个 比如说起点是1，终点是那就很多种情况了，然后这个题目是要去最短路径，肯定要比较，而且我是用列表存的这些节点，索引的时候也有一些特殊性，但是还能得30分，我已经很开心了，我也对这个全局变量和递归又有了新的感悟。哈哈，这个还是用那个字典最好储存这种了。在配上一个矩阵来存放路径，不过我在想，字典能不能后面再放一个列表呢。

def dfs(node,zz):
    global lc
    for i in table.get(node):
        lc+=dp[node][i]
        if i!=zz:
            dfs(i,zz)
       
        
        else: 
            li.append(lc)
            lc=0
            
            

            
    

n,m=map(int,input().split())
dp=[[0 for i in range(n+1)]for j in range(n+1)]
## 万能储存器
table = {
   }
table1={
   }

for i in range(m):
    father, child,mile=map(int,input().split())
    #print(type(father))
    #print(father,child)
    if father not in table:
        table[father]=[]
    
    ##print(table)
    table.get(father).append(child)
    dp[father][child]=mile

lc=0
for i in range(2,n+1):
    li=[]
    dfs(1,i)
    print(min(li))
    
    emmm，看来是我高估了我自己，我用这种套路，也只是得了30分，不过我发现了一个更好的套路，可以解决这个问题。

横向打印二叉树

这道题是很难的，啊，但是一点点去钻研是可以的，加油吧。不断地集思广益，不断地去学习，当然会收获很多了。这个，我以前做那种树的话，用字典来存储关系，这一次，我要用类了，哈哈。

emm，没有成功，照着人家大佬的学习了一下，哎呀，太难了，不愧是大佬，啊，最终也算有了一些收获，list和set以后要加括号。
我也学习了一下类，对类有了了解，但是我会继续努力的。

## 我好像知道是什么意思了，加油
class Node:
    def __init__(self,left=0,right=0,w=0,line=0,leng=0):
        self.left=left
        self.right=right
        self.w=w
        self.line=line
        self.leng=leng
class Solution:
    def printTree(self,nums):
        #将第i个节点和树中本来就存在的cur节点进行比较
        def push(i,cur):
            if node[i].w<node[cur].w:
                if node[cur].left:
                     push(i,node[cur].left)
                else:
                    node[cur].left=i
                    
            else:
                if node[cur].right:
                     push(i,node[cur].right)
                else:
                    node[cur].right=i
            #这个数字的长度
        def wrtLeng(i):
            if i<10:
                node[i].leng=1
            elif i<100:
                node[i].leng=2
            elif i<1000:
                node[i].leng=3
            elif i<10000:
                node[i].leng=4
            else:
                node[i].leng=5
        node=list()
        newnode=Node(w=nums[0])
        node.append(newnode)
        
        for i in range(1,len(nums)):
            add_node=Node(w=nums[i])
            node.append(add_node)
            push(i,0)
        for i in range(len(nums)):
            print(node[node[i].left].w,node[node[i].right].w)

                
nums=[int(i) for i in input().split()]
Solution.printTree(Solution,nums)

货物摆放

这道题就是分解为把2021041820210418 分解为3个因数 然后全排列。
不过 依据我的猜测，想要找3个因数的情况，要先把他分解为两个因数的这种，装到一个列表里面去，
虽然我不知道是为什么。 让我在看一下别人的C版本。
哎呀 我也有点小迷，为什么我3个的那种就不行呢，问题到底出在哪里呢。算了。

a=int(2021041820210418**0.5)
ans=0
rr=set()
jj=set()
for i in range(1,a+1):
    if 2021041820210418%i==0:
        rr.add(i)
        rr.add(2021041820210418//i)
        
for i in rr:
    for j in rr:
        for k in rr:
            if 2021041820210418==i*j*k:
                
                jj.add((i,j,k))


print(len(jj))

目前我终于是去的了一些收获，就是学习之后，可以自己输出了，输入转化为输出
厉害呀
Python-turtle递归画二叉树

大臣的旅费

问题描述
很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。

为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。

聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。

J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？

输入格式
输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数

城市从1开始依次编号，1号城市为首都。

接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）

每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。

输出格式
输出一个整数，表示大臣J最多花费的路费是多少。

样例输入1
5
1 2 2
1 3 1
2 4 5
2 5 4
样例输出1
135
输出格式
大臣J从城市4到城市5要花费135的路费。
虽然超时了，后两项不对，得了50分，虽然不是满分，但是我已经非常开心了，这一段长长的代码是我自己写下来的，哈哈，而且竟然成功了，说明我递归终于有点学明白了，递归回溯。哈哈哈。这一类型的题，我终于不再那么害怕了，哈哈。

def dfs(node,pre):
    global lu
    lu=0
    for i in table.get(node):
        if i!=pre:
            dfs(i,node)
            lu+=dp[i][node]
        
n=int(input())
dp=[[0 for i in range(n+1)]for j in range(n+1)]

table={
   }
for i in range(n-1):
    list=[]
    for s in input().split():
        list.append(int(s))
    if list[0] not in table:
        table[list[0]]=[]
    if list[1] not in table:
        table[list[1]]=[]
    table.get(list[0]).append(list[1])
    
    table.get(list[1]).append(list[0])
    dp[list[0]][list[1]]=dp[list[1]][list[0]]=list[2]
##储存完毕
list1=[]
#print(table)
for i in range(n):
    dfs(i+1,0)
    list1.append(lu)
a=max(list1)
ans=0
for i in range(a):
    ans+=i+1+10
print(ans)

超时了 但也得了80分

连号区间数

问题描述
小明这些天一直在思考这样一个奇怪而有趣的问题：

在1~N的某个全排列中有多少个连号区间呢？这里所说的连号区间的定义是：

如果区间[L, R] 里的所有元素（即此排列的第L个到第R个元素）递增排序后能得到一个长度为R-L+1的“连续”数列，则称这个区间连号区间。

当N很小的时候，小明可以很快地算出答案，但是当N变大的时候，问题就不是那么简单了，现在小明需要你的帮助。

输入格式
第一行是一个正整数N (1 <= N <= 50000), 表示全排列的规模。

第二行是N个不同的数字Pi(1 <= Pi <= N)， 表示这N个数字的某一全排列。

输出格式
输出一个整数，表示不同连号区间的数目。

样例输入1
4
3 2 4 1
样例输出1
7
样例输入2
5
3 4 2 5 1
样例输出2
9

k=int(input())
list=[]
def check(i,j,list):
    list1=list[i:j+1]
    ##print(list1)
    if max(list1)-min(list1)==j-i:
        return 1
##不用排序 最大值减去最小值加1为区间长度 就符合标准
ans=0
for s in input().split():
    list.append(int(s))

for i in range(k):
    for j in range(i,k):#我草我忘了写range要不直接0,和4
           
        if check(i,j,list):
            ans+=1
print(ans)
        

网络寻路

问题描述
X 国的一个网络使用若干条线路连接若干个节点。节点间的通信是双向的。某重要数据包，为了安全起见，必须恰好被转发两次到达目的地。该包可能在任意一个节点产生，我们需要知道该网络中一共有多少种不同的转发路径。

源地址和目标地址可以相同，但中间节点必须不同。

如下图所示的网络。

1 -> 2 -> 3 -> 1 是允许的

1 -> 2 -> 1 -> 2 或者 1 -> 2 -> 3 -> 2 都是非法的。

输入格式
输入数据的第一行为两个整数N M，分别表示节点个数和连接线路的条数(1<=N<=10000; 0<=M<=100000)。

接下去有M行，每行为两个整数 u 和 v，表示节点u 和 v 联通(1<=u,v<=N , u!=v)。

输入数据保证任意两点最多只有一条边连接，并且没有自己连自己的边，即不存在重边和自环。

输出格式
输出一个整数，表示满足要求的路径条数。
样例输入1
3 3
1 2
2 3
1 3
样例输出1
6
样例输入2
4 4
1 2
2 3
3 1
1 4
样例输出2
10

奇怪耶 不知道为啥只有20分，这是为什么呢

def dfs(node,pre,num):
    global ans
    if num==3:
        ans+=1
        return
    for i in table.get(node):
        if i!=pre:
            if dp[node][i]==0:
                 dp[node][i]=1
                 dfs(i,node,num+1)
                 dp[node][i]=0 #回溯
                
                
##            else:
##                if num==2 and i==last:
##                     ans+=1
                     
           
            

global value, table
ans=0
n,m = map(int,input().split())
##value = list(map(int, input().split()))
##value = list(map(lambda x:[0,x],value))
##father, child=list(map(int,input().split()))
    
##print(value)
##value.insert(0,0)
dp=[[0 for i in range(n+1)]for j in range(n+1)]

table = {
   }

for i in range(m):
    father, child=map(int,input().split())
    #print(type(father))
    #print(father,child)
    if father not in table:
        table[father]=[]
    if child not in table:
        table.update({
   child:[]})
    ##print(table)
    table.get(father).append(child)
    table.get(child).append(father)
    
##print(table)
#get(键值)
##for i in range(n):
##    father, child = list(map(int, input().split()))
##    table