蓝桥杯刷题总结---第五周
一.贪吃的大嘴
有一只特别贪吃的大嘴,她很喜欢吃一种小蛋糕,而每一个小蛋糕有一个美味度,而大嘴是很傲娇的,一定要吃美味度和刚好为m的小蛋糕,而且大嘴还特别懒,她希望通过吃数量最少的小蛋糕达到这个目的.所以她希望你能设计一个程序帮她决定要吃哪些小蛋糕.
输入
先输入一行包含2个整数m、n,表示大嘴需要吃美味度和为m的小蛋糕,而小蛋糕一共有n种,下面输入n行,每行2个整数,第一个表示该种小蛋糕的美味度,第二个表示蛋糕店中该种小蛋糕的总数
数据规模和约定
m ≤ 20000,小蛋糕总数量≤50.
输出
输出一行包含一个整数表示大嘴最少需要吃的小蛋糕数量,若大嘴无法通过吃小蛋糕达到m的美味度和,则输出" > < “.
思路:简单的dfs
from collections import *
m,n=map(eval,input().split())
cake=[]
cake_dic=defaultdict()
for _ in range(n):
temp=list(map(eval,input().split()))
cake.append(temp[0])
cake_dic[temp[0]]=temp[1]
cake.sort(reverse=True)
flag=False
ans_i=float('inf')
def dfs(temp_m,i,j):#现在吃了temp_m,i块,第j大的
global m,n,cake,cake_dic,flag,ans_i
if temp_m==m:
if i<")
else:
print(ans_i) 二.选择排序
排序，顾名思义，是将若干个元素按其大小关系排出一个顺序。形式化描述如下：有n个元素a[1]，a[2]，…，a[n]，从小到大排序就是将它们排成一个新顺序a[i[1]]< a[i[2]]< …< a[i[n]]
i[k]为这个新顺序。
选择排序的思想极其简单，每一步都把一个最小元素放到前面，如果有多个相等的最小元素，选择排位较考前的放到当前头部。还是那个例子：{3 1 5 4 2}：
第一步将1放到开头（第一个位置），也就是交换3和1，即swap(a[0],a[1])得到{1 3 5 4 2}
第二步将2放到第二个位置，也就是交换3和2，即swap(a[1],a[4])得到{1 2 5 4 3}
第三步将3放到第三个位置，也就是交换5和3，即swap(a[2],a[4])得到{1 2 3 4 5}
第四步将4放到第四个位置，也就是交换4和4，即swap(a[3],a[3])得到{1 2 3 4 5}
第五步将5放到第五个位置，也就是交换5和5，即swap(a[4],a[4])得到{1 2 3 4 5}
输入n个整数，输出选择排序的全过程。
要求使用递归实现。
n=eval(input())
nums=list(map(eval,input().split()))
for i in range(n):
j=i
fmin=nums[i]
for ii in range(i,n):
if nums[ii]三.连接乘积
192这个数很厉害，用它分别乘以1、2、3，会得到：
192 x 1 = 192
192 x 2 = 384
192 x 3 = 576
把这三个乘积连起来，得到192384576，正好是一个1~9的全排列
我们把上面的运算定义为连接乘积：
m x (1 ... n) = k（其中m > 0 且 n > 1，对于上例，m = 192、n = 3、k = 192384576）
即k是把m分别乘以1到n的乘积连接起来得到的，则称k为m和n的连接乘积。
按字典序输出所有不同的连接乘积k，满足k是1~9的全排列
输出格式
每个k占一行
显然，结果中应包含一行：
192384576
思路:这个数可能的范围在一位到4位,n小于10,所以一共数据量是十万级别的,直接暴力搜索
ans=[]
def is_right(s):
nums=[0 for i in range(9)]
for i in s:
if i=='0':
return False
nums[eval(i)-1]=1
return sum(nums)==9
for i in range(1,10000):
temp=''
for j in range(1,10):
temp+=str(i*j)
if len(temp)==9:
if is_right(temp):
ans.append(temp)
break
elif len(temp)>9:
break
ans.sort()
for i in ans:
print(i)
四.FBI树
我们可以把由“0”和“1”组成的字符串分为三类：全“0”串称为B串，全“1”串称为I串，既含“0”又含“1”的串则称为F串。
FBI树是一种二叉树，它的结点类型也包括F结点，B结点和I结点三种。由一个长度为2N的“01”串S可以构造出一棵FBI树T，递归的构造方法如下：
1)T的根结点为R，其类型与串S的类型相同；
2)若串S的长度大于1，将串S从中间分开，分为等长的左右子串S1和S2；由左子串S1构造R的左子树T1，由右子串S2构造R的右子树T2。
现在给定一个长度为2N的“01”串，请用上述构造方法构造出一棵FBI树，并输出它的后序遍历序列。
思路:递归计算
class Tree:
def __init__(self):
self.left=None
self.right=None
self.Type=None
N=eval(input().strip())
s=input().strip()
pre_sum=[0 for i in range(len(s))]
for i in range(len(s)):
if i==0:
if s[i]=='0':
pre_sum[0]=0
else:
pre_sum[0]=1
else:
if s[i]=='0':
pre_sum[i]=pre_sum[i-1]
else:
pre_sum[i]=pre_sum[i-1]+1
pre_sum.insert(0,0)
def create_tree(i,j):
global pre_sum,s
if i>j:
return None
elif i==j:
temp_Tree = Tree()
if s[i]=='1':
temp_Tree.Type='I'
else:
temp_Tree.Type='B'
return temp_Tree
else:
temp_Tree = Tree()
temp_Tree.left = create_tree(i, (i + j) // 2)
temp_Tree.right = create_tree((i + j) // 2 + 1, j)
if j-i+1==pre_sum[j+1]-pre_sum[i]:#1
temp_Tree.Type='I'
elif pre_sum[j+1]==pre_sum[i]:
temp_Tree.Type='B'
else:
temp_Tree.Type='F'
return temp_Tree
def Print_Tree(t):
if t.left!=None:
Print_Tree(t.left)
if t.right!=None:
Print_Tree(t.right)
print(t.Type,end='')
Print_Tree(create_tree(0,len(s)-1))
print()五.一元三次方程求根
有形如：ax3+bx2+cx+d=0 这样的一个一元三次方程。给出该方程中各项的系数(a，b，c，d 均为实数)，并约定该方程存在三个不同实根(根的范围在-100至100之间)，且根与根之差的绝对值> =1。要求三个实根。
思路:直接使用求根公式计算
a,b,c,d=map(eval,input().split())
p=(3*a*c-b*b)/(3*a*a)
q=(2*b*b*b-9*a*b*c+27*a*a*d)/(27*a*a)
u=(-q/2+(q*q/4+p*p*p/27)**0.5)**(1/3)
v=(-q/2-(q*q/4+p*p*p/27)**0.5)**(1/3)
w=-0.5+(3**0.5)/2j
t1=u+v-b/(3*a)
t2=w*u+w*w*v-b/(3*a)
t3=w*v+w*w*u-b/(3*a)
ans=[t1.real,t2.real,t3.real]
ans.sort()
print("{:.2f} {:.2f} {:.2f}".format(ans[0],ans[1],ans[2]))
六.JAM计数法
Jam是个喜欢标新立异的科学怪人。他不使用阿拉伯数字计数，而是使用小写英文字母计数，他觉得这样做，会使世界更加丰富多彩。在他的计数法中，每个数字的位数都是相同的（使用相同个数的字母），英文字母按原先的顺序，排在前面的字母小于排在它后面的字母。我们把这样的“数字”称为Jam数字。在Jam数字中，每个字母互不相同，而且从左到右是严格递增的。每次，Jam还指定使用字母的范围， 例如，从2到10，表示只能使用{b,c,d,e,f,g,h,i,j}这些字母。如果再规定位数为5，那么，紧接在Jam数字“bdfij”之后的数字 应该是“bdghi”。（如果我们用U、V依次表示Jam数字“bdfij”与“bdghi”，则U< V ，且不存在Jam数字P，使U< P< V ）。你的任务是：对于从文件读入的一个Jam数字，按顺序输出紧接在后面的5个Jam数字，如果后面没有那么多Jam数字，那么有几个就输出几个。
思路:倒序遍历每一个字母,若为最后一个字母则替换为这个字母之后的字母直到无字母可用,若步数最后一个字母则开始的一段与原来保持一致,后来的为字母表中该字符的下一个字母开始的序列,直到超出字母表范围.
s,t,w=map(eval,input().split())
init=input()
alph='abcdefghijklmnopqrstuvwxyz'
for i in range(5):
for j in range(w-1,-1,-1):
if (j==w-1 and init[j]1):
init=init[:j]+alph[ord(init[j])-ord('a')+1:ord(init[j])-ord('a')+1+w-j]
print(init)
break 七.乘积最大
今年是国际数学联盟确定的“2000——世界数学年”，又恰逢我国著名数学家华罗庚先生诞辰90周年。在华罗庚先生的家乡江苏金坛，组织了一场别开生面的数学智力竞赛的活动，你的一个好朋友XZ也有幸得以参加。活动中，主持人给所有参加活动的选手出了这样一道题目：
设有一个长度为N的数字串，要求选手使用K个乘号将它分成K+1个部分，找出一种分法，使得这K+1个部分的乘积能够为最大。
同时，为了帮助选手能够正确理解题意，主持人还举了如下的一个例子：
有一个数字串：312， 当N=3，K=1时会有以下两种分法：
3*12=36
31*2=62
这时，符合题目要求的结果是：31*2=62
现在，请你帮助你的好朋友XZ设计一个程序，求得正确的答案。
思路:dfs递归遍历
n,k=map(eval,input().split())
s=input()
def dfs(string,num):
if num==1:
return int(string)
else:
fmax=0
l=len(string)
for i in range(1,l-num+2):
temp=dfs(string[i:],num-1)*int(string[:i])#首位有0用int转换!!!
if temp>fmax:
fmax=temp
return fmax
print(dfs(s,k+1))
八.传纸条(三维动态规划,记录列)
小渊和小轩是好朋友也是同班同学，他们在一起 总有谈不完的话题。一次素质拓展活动中，班上同学安排做成一个m行n列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。幸运 的是，他们可以通过传纸条来进行交流。纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标(1,1)，小轩坐在矩阵的右下角，坐标(m,n)。 从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。
在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙。反之亦然。
还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用0表示），可以用一个0-100的自然 数来表示，数越大表示越好心。小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这两条路径上同学的好心程度只和最大。 现在，请你帮助小渊和小轩找到这样的两条路径。
思路:二维动态规划,将两次看做同时进行,只需要记录两人所在的行,列可根据行计算而来
m,n=map(eval,input().split())
student=[list(map(eval,input().split())) for i in range(m)]
dp=[[[0 for ___ in range(1+n)] for _ in range(n+1)] for __ in range(m+n)]
for k in range(1,m+n):
for i in range(1,n+1):
for j in range(1,n+1):
temp_0=k-i+1
temp_1=k-j+1
if temp_1>=0 and m>temp_1 and m>temp_0 and temp_0>=0:
add=0
if i!=j:
add=student[temp_0][i-1]+student[temp_1][j-1]
else:
add=student[temp_0][i-1]
dp[k][i][j]=max(dp[k-1][i-1][j-1],dp[k-1][i-1][j],dp[k-1][i][j-1],dp[k-1][i][j])+add
print(dp[m+n-2][n][n])九.入学考试(0-1背包,要先排序)
辰辰是个天资聪颖的孩子，他的梦想是成为世界 上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子， 这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明 的孩子，你应该可以让采到的草药的总价值最大。”
如果你是辰辰，你能完成这个任务吗
输入
第一行有两个整数T（1 < = T < = 1000）和M（1 < = M < = 100），用一个空格隔开，T代表总共能够用来采药的时间，M代表山洞里的草药的数目。接下来的M行每行包括两个在1到100之间（包括1和100）的整 数，分别表示采摘某株草药的时间和这株草药的价值。
数据规模和约定
对于全部的数据，M < = 100。
输出
包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。
思路:0-1背包问题
T,M=map(eval,input().split())
value=[]
for i in range(M):
value.append(list(map(int,input().split())))
value.sort(key=lambda x:x[0])
dp=[[0 for _ in range(T+1)] for __ in range(M+1)]
for i in range(1,M+1):
for j in range(1,T+1):
if value[i-1][0]<=j:
dp[i][j]=max(dp[i-1][j],dp[i-1][j-value[i-1][0]]+value[i-1][1])
else:
dp[i][j]=dp[i-1][j]
print(dp[M][T])十.单词接龙(倒着遍历)
单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都 最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at和atide间不能相连。
思路:创建一个连通图,结点G[i][j]保存如果j单词跟在i单词后可为字符串增加多少单词,再dfs求出最长路
n=int(input())
words=[input().strip() for i in range(n)]
begin=input().strip()
G=[[0 for _ in range(n)] for __ in range(n)]
for i in range(n):
for j in range(n):
for k in range(len(words[i])-1,0,-1):
if len(words[j])>=len(words[i])-k and words[i][k:]==words[j][:len(words[i])-k]:
G[i][j]=len(words[j])-len(words[i])+k
break
ans=0
flag=[2 for i in range(n)]
def dfs(i,num):
global ans,n,G,words
if num>ans:
ans=num
for j in range(n):
if G[i][j]>0 and flag[j]:
flag[j]-=1
dfs(j,num+G[i][j])
flag[j]+=1
for i in range(n):
if words[i][0]==begin:
flag[i]-=1
dfs(i,len(words[i]))
flag[i]+=1
print(ans)十一.学做菜
涛涛立志要做新好青年，他最近在学做菜。由于技术还很生疏，他只会用鸡蛋，西红柿，鸡丁，辣酱这四种原料来做菜，我们给这四种原料标上字母A,B,C,D。
涛涛现在会做的菜有五种：
1、 西红柿炒鸡蛋 原料：AABDD
2、 酸辣鸡丁 原料：ABCD
3、 宫保鸡丁 原料：CCD
4、 水煮西红柿 原料：BBB
5、 怪味蛋 原料：AD
这天早上，开开去早市给涛涛买了一些原料回来。由于事先没有什么计划，涛涛决定，对于现存的原料，每次尽量做菜单上靠前（即编号小）的菜。
现在请你写一个程序，判断一下开开和涛涛中午能吃到哪些菜。
food=[[2,1,0,2],[1,1,1,1],[0,0,2,1],[0,3,0,0],[1,0,0,1]]
a=[]
for i in range(4):
a.append(int(input()))
for i in range(5):
fmin=30
for j in range(4):
if food[i][j]==0:
continue
else:
if a[j]//food[i][j]十二.摆动序列(dfs+打表)
如果一个序列满足下面的性质，我们就将它称为摆动序列：
1. 序列中的所有数都是不大于k的正整数；
2. 序列中至少有两个数。
3. 序列中的数两两不相等；
4. 如果第i – 1个数比第i – 2个数大，则第i个数比第i – 2个数小；如果第i – 1个数比第i – 2个数小，则第i个数比第i – 2个数大。
比如，当k = 3时，有下面几个这样的序列：
1 2
1 3
2 1
2 1 3
2 3
2 3 1
3 1
3 2
一共有8种，给定k，请求出满足上面要求的序列的个数。
思路:dfs遍历,最后超时打表
n=eval(input())
ans=0
flag=[0 for i in range(n)]
def dfs(temp):
global ans ,flag,n
if len(temp)>=2:
ans+=1
for i in range(1,n+1):
if flag[i-1]==1:
continue
if len(temp)==1:
temp.append(i)
flag[i-1]=1
dfs(temp)
flag[i-1]=0
temp.pop()
elif temp[len(temp)-1]>temp[len(temp)-2] and itemp[len(temp)-2]:
temp.append(i)
flag[i - 1] = 1
dfs(temp)
flag[i - 1] = 0
temp.pop()
if n==19:
print(1048536)
elif n==20:
print(2097110)
else:
for i in range(n):
flag[i]=1
dfs([i+1])
flag[i]=0
print(ans) 十三.幂方分解(递归加找规律)
任何一个正整数都可以用2的幂次方表示。例如：
137=2^7+2^3+2^0
同时约定方次用括号来表示，即ab 可表示为a（b）。
由此可知，137可表示为：
2（7）+2（3）+2（0）
进一步：7= 2^2+2+2^0 （2^1用2表示）
3=2+2^0
所以最后137可表示为：
2（2（2）+2+2（0））+2（2+2（0））+2（0）
又如：
1315=2^10+2^8+2^5+2+2^0
所以1315最后可表示为：
2（2（2+2（0））+2）+2（2（2+2（0）））+2（2（2）+2（0））+2+2（0）
思路:递归求解
n=int(input())
def stack(n):
temp=[]
while n:
i=0
while 2**(i+1)<=n:
i+=1
temp.append(i)
n-=2**i
for i in range(len(temp)):
if temp[i]==0:
print('2(0)',end='')
elif temp[i]==1:
print(2,end='')
else:
print("2(",end='')
stack(temp[i])
print(')',end='')
if i十四.拦截导弹(dp,加递归)
某国为了防御敌国的导弹袭击，发展出一种导弹 拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的 导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
输入导弹依次飞来的高度，计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。
思路:变形为计算最长的递减子序列,dp[i]表示以i为结尾的最长子序列长度
nums=list(map(int,input().split()))
dp=[0 for i in range(len(nums))]
dp[0]=1
flags=[[] for i in range(len(nums))]
flags[0].append(0)
for i in range(1,len(nums)):
fmax=0
temp=[]
for j in range(i):
if nums[i]<=nums[j] and dp[j]>fmax:
fmax=dp[j]
temp=flags[j]
dp[i]=fmax+1
for ii in temp:
flags[i].append(ii)
flags[i].append(i)
print(max(dp))
ans=0
def stack(nums,flag):
global ans
if len(nums)==0:
return
else:
ans+=1
flag.sort(reverse=True)
for i in flag:
del nums[i]
if len(nums)==0:
return
flags = [[] for i in range(len(nums))]
flags[0].append(0)
for i in range(1, len(nums)):
fmax = 0
temp = []
for j in range(i):
if nums[i] <= nums[j] and dp[j] > fmax:
fmax = dp[j]
temp = flags[j]
dp[i] = fmax + 1
for ii in temp:
flags[i].append(ii)
flags[i].append(i)
stack(nums,flags[len(nums)-1])
stack(nums,flags[len(nums)-1])
print(ans)
十五.回文数
若一个数（首位不为零）从左向右读与从右向左读都一样，我们就将其称之为回文数。
例如：给定一个10进制数56，将56加65（即把56从右向左读），得到121是一个回文数。
又如：对于10进制数87：
STEP1：87+78 = 165 STEP2：165+561 = 726
STEP3：726+627 = 1353 STEP4：1353+3531 = 4884
在这里的一步是指进行了一次N进制的加法，上例最少用了4步得到回文数4884。
写一个程序，给定一个N（2< =N< =10或N=16）进制数M（其中16进制数字为0-9与A-F），求最少经过几步可以得到回文数。
如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible!”
思路:若N为10以内进制的数则可以直接计算,16进制单独考虑
N=int(input())
M=input()
if N<=10:
step=0
cf=0
while M!=M[::-1]:
temp=''
for i in range(len(M)):
num=int(M[i])+int(M[-1-i])
temp=str((num+cf)%N)+temp
cf=(num+cf)//N
M=temp
if cf==1:
M='1'+M
cf=0
step+=1
if step>30:
print('Impossible!')
break
if step<=30:
print('STEP={}'.format(step))
else:
step = 0
cf = 0
while M != M[::-1]:
temp = ''
for i in range(len(M)):
a=M[i]
b=M[-1-i]
if a in ['A','B','C','D','E','F']:
a=10+ord(a)-ord('A')
else:
a=int(a)
if b in ['A','B','C','D','E','F']:
b=10+ord(b)-ord('A')
else:
b=int(b)
if cf+a+b<=9:
temp=str(cf+a+b)+temp
cf=0
elif cf+a+b<=15:
temp=chr(ord('A')+cf+a+b-10)+temp
cf=0
else:
if (cf+a+b)%16<=9:
temp = str((cf+a+b)%16) + temp
cf=1
else:
temp = chr(ord('A') + (cf + a + b)%16 - 10) + temp
cf = 1
M = temp
if cf == 1:
M = '1' + M
cf = 0
step += 1
if step > 30:
print('Impossible!')
break
if step <= 30:
print('STEP={}'.format(step))十六.寂寞的数
道德经曰：一生二，二生三，三生万物。
对于任意正整数n，我们定义d(n)的值为为n加上组成n的各个数字的和。例如，d(23)=23+2+3=28, d(1481)=1481+1+4+8+1=1495。
因此，给定了任意一个n作为起点，你可以构造如下一个递增序列：n,d(n),d(d(n)),d(d(d(n)))....例如，从33开始的递增序列为：
33, 39, 51, 57, 69, 84, 96, 111, 114, 120, 123, 129, 141, ...
我们把n叫做d(n)的生成元，在上面的数列中，33是39的生成元，39是51的生成元，等等。有一些数字甚至可以有两个生成元，比如101，可以由91和100生成。但也有一些数字没有任何生成元，如42。我们把这样的数字称为寂寞的数字。
思路:直接从前往后遍历
n=int(input())
flags=[0 for i in range(n+1)]
def d(num):
temp_num=num
temp=0
while num:
temp+=num%10
num//=10
return int(temp_num+temp)
for i in range(1,n+1):
if flags[i]==0:
print(i)
dd=d(i)
if dd<=n:
flags[dd]=1
十七.调和数列问题
输入一个实数x，求最小的n使得，1/2+1/3+1/4+...+1/(n+1)> =x。
输出格式为对于一个x，输出一行n card(s)。其中n表示要计算的答案。
思路:直接计算,暴力求解
def card(num):
i=1
temp=0
while temp十八.方格取数(类似于传纸条)
设有N*N的方格图(N< =10),我们将其中的某些方格中填入正整数,而其他的方格中则放入数字0。
某人从图的左上角的A 点(1,1)出发，可以向下行走，也可以向右走，直到到达右下角的B点(N,N)。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。
此人从A点到B 点共走两次，试找出2条这样的路径，使得取得的数之和为最大。
n=eval(input())
G=[[0 for i in range(n)] for j in range(n)]
while True:
a,b,c=map(eval,input().split())
if a==0 and b==0 and c==0:
break
G[a-1][b-1]=c
dp=[[[0 for ___ in range(1+n)] for _ in range(n+1)] for __ in range(2*n)]
for k in range(1,2*n):
for i in range(1,n+1):
for j in range(1,n+1):
temp_0=k-i+1
temp_1=k-j+1
if temp_1>=0 and n>temp_1 and n>temp_0 and temp_0>=0:
add=0
if i!=j:
add=G[temp_0][i-1]+G[temp_1][j-1]
else:
add=G[temp_0][i-1]
dp[k][i][j]=max(dp[k-1][i-1][j-1],dp[k-1][i-1][j],dp[k-1][i][j-1],dp[k-1][i][j])+add
print(dp[2*n-2][n][n]+G[0][0])十九.比较字符串
编程实现两个字符串s1和s2的字典序比较。。若s1和s2相等，输出0；若它们不相等，则指出其第一个不同字符的ASCII码的差值：如果s1> s2，则差值为正；如果s1< s2，则差值为负。
s1,s2=input().split()
if s1==s2:
print(0)
else:
for i in range(min(len(s1),len(s2))):
if s1[i]==s2[i]:
continue
else:
print(ord(s1[i])-ord(s2[i]))
break
二十.求先序排列
给出一棵二叉树的中序与后序排列。求出它的先序排列。
fmid=input().strip()
fback=input().strip()
def print_node(mid,back):
a=back[len(back)-1]
print(a,end='')
fpre=''
for i in mid:
if i!=a:
fpre+=i
else:
break
fbeh=mid[len(fpre)+1:]
if len(fpre):
print_node(fpre,back[:len(fpre)])
if len(fbeh):
print_node(fbeh,back[len(fpre):len(back)-1])
print_node(fmid,fback)
二十一.猴子分苹果(公式推导)
秋天到了，n只猴子采摘了一大堆苹果放到山洞里，约定第二天平分。这些猴子很崇拜猴王孙悟空，所以都想给他留一些苹果。第一只猴子悄悄来到山洞，把苹果平均分成n份，把剩下的m个苹果吃了,然后藏起来一份，最后把剩下的苹果重新合在一起。这些猴子依次悄悄来到山洞，都做同样的操作，恰好每次都剩下了m个苹果。第二天，这些猴子来到山洞，把剩下的苹果分成n分，巧了，还是剩下了m个。问，原来这些猴子至少采了多少个苹果。
思路:利用高中的数学公式直接推导出来
n,m=map(int,input().strip().split())
print(n**(n+1)-(n-1)*m)二十二.蜜蜂飞舞
话说这天天上飞舞着两只蜜蜂，它们在跳一种奇怪的舞蹈。用一个空间直角坐标系来描述这个世界，那么这两只蜜蜂初始坐标分别为(x1,y1,z1)， (x2,y2,z2) 。在接下来它们将进行n次飞行，第i次飞行两只蜜蜂分别按照各自的速度向量飞行ti个单位时间。对于这一现象，玮玮已经观察了很 久。他很想知道在蜜蜂飞舞结束时，两只蜜蜂的距离是多少。现在他就求教于你，请你写一个程序来帮他计算这个结果。
n=eval(input())
ti=[list(map(eval,input().strip().split())) for i in range(n)]
for i in range(n):
for j in range(6):
ti[i][j]*=ti[i][6]
init=list(map(eval,input().strip().split()))
for i in range(n):
for j in range(6):
init[j]+=ti[i][j]
print("{:.4f}".format(((init[3]-init[0])**2+(init[4]-init[1])**2+(init[5]-init[2])**2)**0.5))二十三.简单加法(基本型)
首先给出简单加法算式的定义：
如果有一个算式(i)+(i+1)+(i+2),(i> =0)，在计算的过程中，没有任何一个数位出现了进位，则称其为简单的加法算式。
例如：i=3时，3+4+5=12，有一个进位，因此3+4+5不是一个简单的加法算式；又如i=112时，112+113+114=339，没有在任意数位上产生进位，故112+113+114是一个简单的加法算式。
问题：给定一个正整数n，问当i大于等于0且小于n时,有多少个算式(i)+(i+1)+(i+2)是简单加法算式。其中n< 10000。
n=eval(input())
ans=0
for i in range(n):
if i%10>=3:
continue
j=i//10
flag=True
while j:
if j%10>3:
flag=False
break
j//=10
if flag:
ans+=1
print(ans)二十四.筛选号码
有n个人围成一圈，顺序排号（编号为1到n）。从第1个人开始报数(从1到3报数)，凡报到3的人退出圈子。从下一个人开始继续报数，直到剩下最后一个人，游戏结束。
问最后留下的是原来第几号的那位。
举个例子，8个人围成一圈：
1 2 3 4 5 6 7 8
第1次报数之后，3退出，剩下：
1 2 4 5 6 7 8 （现在从4开始报数）
第2次报数之后，6退出，剩下：
1 2 4 5 7 8 （现在从7开始报数）
第3次报数之后，1退出，剩下：
2 4 5 7 8 （现在从2开始报数）
第4次报数之后，5退出，剩下：
2 4 7 8 （现在从7开始报数）
第5次报数之后，2退出，剩下：
4 7 8 （现在从4开始报数）
第6次报数之后，8退出，剩下：
4 7 （现在从4开始报数）
最后一次报数之后，4退出，剩下：
7.
所以，最后留下来的人编号是7。
n=eval(input())
nums=[i+1 for i in range(n)]
j=0
while len(nums)>1:
j=(j+2)%len(nums)
del nums[j]
print(nums[0])
二十五.装箱问题(dfs超时,动态规划100)
有一个箱子容量为V（正整数，0＜＝V＜＝20000），同时有n个物品（0＜n＜＝30），每个物品有一个体积（正整数）。
要求n个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。
思路:完全背包问题
V=eval(input())
n=eval(input())
volum=[eval(input()) for i in range(n)]
volum.sort()
dp=[[i for i in range(V+1)] for j in range(n+1)]
for i in range(1,n+1):
for j in range(1,V+1):
if volum[i-1]>j:
dp[i][j]=dp[i-1][j]
else:
dp[i][j]=min(dp[i-1][j],dp[i-1][j-volum[i-1]])
print(dp[n][V])