目录
day1
1. 十六进制八进制转换
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0~9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
【提示】
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
n = int(input())
a=list()
for i in range(n):
a.append(int(input(),16))
for i in range(n):
print(oct(a[i])[2:])
#最后的输出使用切片将前导0舍去2.十进制转十六进制
问题描述
十六进制数是在程序设计时经常要使用到的一种整数的表示方式。它有0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F共16个符号，分别表示十进制数的0至15。十六进制的计数方法是满16进1，所以十进制数16在十六进制中是10，而十进制的17在十六进制中是11，以此类推，十进制的30在十六进制中是1E。
给出一个非负整数，将它表示成十六进制的形式。输入格式
输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647
输出格式
输出这个整数的16进制表示
样例输入
30
样例输出
1E
print(hex(int(input())).upper()[2:])
#hex().upper()表示大写16进制
#[2:]为切片，去除前导0
3.回文数
资源限制
内存限制：512.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
123321是一个非常特殊的数，它从左边读和从右边读是一样的。
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。输入格式
输入一行，包含一个正整数n。
输出格式
按从小到大的顺序输出满足条件的整数，每个整数占一行。
样例输入
52
样例输出
899998
989989
998899数据规模和约定
1<=n<=54。
#way1：
n=int(input())
a=10000
b=10000
while b<100000:
a=b
a1=a//10000 #取出来第五位
a=a%10000
a2=a//1000
a=a%1000
a3=a//100
a=a%100
a4=a//10
a5=a%10
b+=1
if a1+a2+a3+a4+a5==n and a1==a5 and a2==a4:
print(a1*10000+a2*1000+a3*100+a4*10+a5)
a=100000
b=100000
while b<1000000:
a=b
a1=a//100000 #取出来第五位
a=a%100000
a2=a//10000
a=a%10000
a3=a//1000
a=a%1000
a4=a//100
a=a%100
a5=a//10
a6=a%10
b+=1
if a1+a2+a3+a4+a5+a6==n and a1==a6 and a2==a5 and a3==a4:
print(a1*100000+a2*10000+a3*1000+a4*100+a5*10+a6)#way2
n=int(input())
for i in range(10000,1000000):
sum=0
str1=str(i)
for j in range(len(str1)):
sum+=int(str1[j])
str2=str1[::-1]
if str1==str2 and sum==n:
print(i)
4.回文数
资源限制
内存限制：512.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
1221是一个非常特殊的数，它从左边读和从右边读是一样的，编程求所有这样的四位十进制数。
输出格式
按从小到大的顺序输出满足条件的四位十进制数。
#way1
for i in range(1000,10000):
a=i
a1=a//1000
a%=1000
a2=a//100
a%=100
a3=a//10
a%=10
if a1==a and a2==a3:
print(a1*1000+a2*100+a3*10+a)
#way2
for i in range(1000,10000):
str1=str(i)
str2=str1[::-1]
if str1==str2:
print(i)
5.特殊的数字
内存限制：512.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
153是一个非常特殊的数，它等于它的每位数字的立方和，即153=1*1*1+5*5*5+3*3*3。编程求所有满足这种条件的三位十进制数。
输出格式
按从小到大的顺序输出满足条件的三位十进制数，每个数占一行。
for i in range(100,1000):
sum=0
str1=str(i)
for j in range(len(str1)):
sum+=pow(int(str1[j]),3)
if sum==i:
print(i)
6.杨辉三角
问题描述
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。
它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
下面给出了杨辉三角形的前4行：
1
1 1
1 2 1
1 3 3 1
给出n，输出它的前n行。
输入格式
输入包含一个数n。
输出格式
输出杨辉三角形的前n行。每一行从这一行的第一个数开始依次输出，中间使用一个空格分隔。请不要在前面输出多余的空格。
样例输入
4
样例输出
1
1 1
1 2 1
1 3 3 1数据规模与约定
1 <= n <= 34。
n=int(input())
a=list()
output=0
for i in range(n):
if i ==0:
output=1
print(output)
a.append(output)
for j in range(i):
if i==1 and j==0:
print(1, end=' ')
a.append(1)
print(1)
a.append(1)
continue
if j==0 :
output=1
print(1,end=' ')
a.append(output)
elif j!=i :
output=a[int(0.5*i*(i-1)+j)]+a[int(0.5*i*(i-1)+j-1)]
print(output,end=' ')
a.append(output)
if j==(i-1):
output=1
print(output)
a.append(output)
day2
1.数列排序
资源限制
内存限制：512.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200
输入格式
第一行为一个整数n。
第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。输出格式
输出一行，按从小到大的顺序输出排序后的数列。
样例输入
5
8 3 6 4 9样例输出
3 4 6 8 9
n=int(input())
if 1<=n<=200:
a=list(map(int, input().split()))
a.sort()
for i in a:
print(i,end=' ')
2.查找整数
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
给出一个包含n个整数的数列，问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数，为给定的数列，数列中的每个数都不大于10000。
第三行包含一个整数a，为待查找的数。
输出格式
如果a在数列中出现了，输出它第一次出现的位置(位置从1开始编号)，否则输出-1。
样例输入
6
1 9 4 8 3 9
9样例输出
2
数据规模与约定
1 <= n <= 1000。
n = int(input())
a = list(map(int, input().split()))
m = int(input())
flag=True
for i in a:
if m == i:
print(a.index(m) + 1)
flag=False
break
if flag:
print(-1)
3.数列特征
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
给出n个数，找出这n个数的最大值，最小值，和。
输入格式
第一行为整数n，表示数的个数。
第二行有n个数，为给定的n个数，每个数的绝对值都小于10000。输出格式
输出三行，每行一个整数。第一行表示这些数中的最大值，第二行表示这些数中的最小值，第三行表示这些数的和。
样例输入
5 1 3 -2 4 5Data
样例输出
5 -2 11Data
数据规模和约定
1 <= n <= 10000。
n = int(input())
a=list(map(int,input().split()))
print(max(a))
print(min(a))
sum=0
for i in a:
sum+=i
print(sum)4.字母图形
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
输入格式
输入一行，包含两个整数n和m，分别表示你要输出的图形的行数的列数。
输出格式
输出n行，每个m个字符，为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC数据规模与约定
1 <= n, m <= 26。
a, b = map(int, input().split())
for i in range(a):
for j in range(b):
print(chr(65+abs(i - j)), end='')
print('')>>>ord('a')
97
>>> ord('b')
98
>>> ord('c')
99
>>>print chr(0x30), chr(0x31), chr(0x61) # 十六进制
0 1 a
>>> print chr(48), chr(49), chr(97) # 十进制
0 1 a5.01字串
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
对于长度为5位的一个01串，每一位都可能是0或1，一共有32种可能。它们的前几个是：
00000
00001
00010
00011
00100
请按从小到大的顺序输出这32种01串。
输入格式
本试题没有输入。
输出格式
输出32行，按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011
<以下部分省略>
#way1
for i in range(32):
if i <0b10:#1位数
print('0000',end='')
print(bin(i)[2:7])
elif 0b10<=i <0b100:#2位数
print('000',end='')
print(bin(i)[2:7])
elif 0b100<=i<0b1000:
print('00',end='')
print(bin(i)[2:7])
elif 0b1000<=i<0b10000:
print('0',end='')
print(bin(i)[2:7])
else:
print(bin(i)[2:7])
#way2
for i in range(32):
a=str(bin(i))
a=a[2:]
a='0000'+a
print(a[-5:])
#利用切片来控制输出的内容，a[-5:]表示从倒数第5个开始取，a[arg1:arg2:arg3]中，第一个位起始，第二
#个为终止，第三个为步长6.闰年判断
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
给定一个年份，判断这一年是不是闰年。
当以下情况之一满足时，这一年是闰年：
1. 年份是4的倍数而不是100的倍数；
2. 年份是400的倍数。
其他的年份都不是闰年。
输入格式
输入包含一个整数y，表示当前的年份。
输出格式
输出一行，如果给定的年份是闰年，则输出yes，否则输出no。
说明：当试题指定你输出一个字符串作为结果（比如本题的yes或者no，你需要严格按照试题中给定的大小写，写错大小写将不得分。
样例输入
2013
样例输出
no
样例输入
2016
样例输出
yes
数据规模与约定
1990 <= y <= 2050。
year=int(input())
if (year%4==0 and year%100!=0) or (year%400 ==0):
print('yes')
else:
print('no')
#大小写转换
str = "www.ru p"
print(str.upper()) # 把所有字符中的小写字母转换成大写字母
print(str.lower()) # 把所有字符中的大写字母转换成小写字母
print(str.capitalize()) # 把第一个字母转化为大写字母，其余小写
print(str.title()) # 把每个单词的第一个字母转化为大写，其余小写
7.斐波那契数列
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们只要能算出这个余数即可，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000。
n=int(input())
F1=F2=1
for i in range(3,n+1):
F1,F2=F2%10007,(F1+F2)%10007
print(F2%10007)
#直接使用递归算法会超时，直接取余再计算即可利用拆包的方式进行赋值8.圆的面积
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
给定圆的半径r，求圆的面积。
输入格式
输入包含一个整数r，表示圆的半径。
输出格式
输出一行，包含一个实数，四舍五入保留小数点后7位，表示圆的面积。
说明：在本题中，输入是一个整数，但是输出是一个实数。
对于实数输出的问题，请一定看清楚实数输出的要求，比如本题中要求保留小数点后7位，则你的程序必须严格的输出7位小数，输出过多或者过少的小数位数都是不行的，都会被认为错误。
实数输出的问题如果没有特别说明，舍入都是按四舍五入进行。
样例输入
4
样例输出
50.2654825
数据规模与约定
1 <= r <= 10000。
提示
本题对精度要求较高，请注意π的值应该取较精确的值。你可以使用常量来表示π，比如PI=3.14159265358979323，也可以使用数学公式来求π，比如PI=atan(1.0)*4。
import math
r=int(input())
pi=math.atan(1)*4
print('{:.7f}'.format(pi*pow(r,2)))
#利用format对输出的位数进行限制格式为print('{:.xf}.format(xx)')
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:-.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |
| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
| 0.25 | {:.2%} | 25.00% | 百分比格式 |
| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |
| 13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
| 13 | {:<10d} | 13 | 左对齐 (宽度为10) |
| 13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
| 11 | '{:b}'.format(11)
'{:d}'.format(11)
'{:o}'.format(11)
'{:x}'.format(11)
'{:#x}'.format(11)
'{:#X}'.format(11) | 1011 11 13 b 0xb 0XB | 进制 |
9.序列求和
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
求1+2+3+...+n的值。
输入格式
输入包括一个整数n。
输出格式
输出一行，包括一个整数，表示1+2+3+...+n的值。
样例输入
4
样例输出
10
样例输入
100
说明：有一些试题会给出多组样例输入输出以帮助你更好的做题。
一般在提交之前所有这些样例都需要测试通过才行，但这不代表这几组样例数据都正确了你的程序就是完全正确的，潜在的错误可能仍然导致你的得分较低。
样例输出
5050
数据规模与约定
1 <= n <= 1,000,000,000。
说明：请注意这里的数据规模。
本题直接的想法是直接使用一个循环来累加，然而，当数据规模很大时，这种“暴力”的方法往往会导致超时。此时你需要想想其他方法。你可以试一试，如果使用1000000000作为你的程序的输入，你的程序是不是能在规定的上面规定的时限内运行出来。
本题另一个要值得注意的地方是答案的大小不在你的语言默认的整型(int)范围内，如果使用整型来保存结果，会导致结果错误。
如果你使用C++或C语言而且准备使用printf输出结果，则你的格式字符串应该写成%I64d以输出long long类型的整数。
n=int(input())
sum=0
print(int((1+n)*n/2))
#循环累加会超时，直接使用等差数列公式进行计算10.阶乘计算
题目描述
输入一个正整数n，输出n!的值。
其中n!=1*2*3*…*n。
算法描述
n!可能很大，而计算机能表示的整数范围有限，需要使用高精度计算的方法。使用一个数组A来表示一个大整数a，A[0]表示a的个位，A[1]表示a的十位，依次类推。
将a乘以一个整数k变为将数组A的每一个元素都乘以k，请注意处理相应的进位。
首先将a设为1，然后乘2，乘3，当乘到n时，即得到了n!的值。输入格式
输入包含一个正整数n，n< =1000。
输出格式
输出n!的准确值。
样例输入
复制
10样例输出
复制
3628800
import math
n=int(input())
print(math.factorial(n))
#直接使用库函数math.factorial(x)day3
1.Huffuman树
Huffman树在编码中有着广泛的应用。在这里，我们只关心Huffman树的构造过程。
给出一列数{pi}={p0, p1, …, pn-1}，用这列数构造Huffman树的过程如下：
1. 找到{pi}中最小的两个数，设为pa和pb，将pa和pb从{pi}中删除掉，然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
2. 重复步骤1，直到{pi}中只剩下一个数。
在上面的操作过程中，把所有的费用相加，就得到了构造Huffman树的总费用。
本题任务：对于给定的一个数列，现在请你求出用该数列构造Huffman树的总费用。
例如，对于数列{pi}={5, 3, 8, 2, 9}，Huffman树的构造过程如下：
1. 找到{5, 3, 8, 2, 9}中最小的两个数，分别是2和3，从{pi}中删除它们并将和5加入，得到{5, 8, 9, 5}，费用为5。
2. 找到{5, 8, 9, 5}中最小的两个数，分别是5和5，从{pi}中删除它们并将和10加入，得到{8, 9, 10}，费用为10。
3. 找到{8, 9, 10}中最小的两个数，分别是8和9，从{pi}中删除它们并将和17加入，得到{10, 17}，费用为17。
4. 找到{10, 17}中最小的两个数，分别是10和17，从{pi}中删除它们并将和27加入，得到{27}，费用为27。
5. 现在，数列中只剩下一个数27，构造过程结束，总费用为5+10+17+27=59。输入格式
输入的第一行包含一个正整数n（n< =100）。
接下来是n个正整数，表示p0, p1, …, pn-1，每个数不超过1000。输出格式
输出用这些数构造Huffman树的总费用。
样例输入
复制
5 5 3 8 2 9样例输出
复制
59
n=int(input())
a=list(map(int,input().split()))
waste=0
for i in range(n):
if len(a):
pa = a.pop(a.index(min(a)))
if len(a):
pb = a.pop(a.index(min(a)))
p_new = pa + pb
a.append(p_new)
waste+=p_new
print(waste)
#使用index定位，利用pop弹出最小元素，利用append添加新的节点2.印章——DP
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
共有n种图案的印章，每种图案的出现概率相同。小A买了m张印章，求小A集齐n种印章的概率。
输入格式
一行两个正整数n和m
输出格式
一个实数P表示答案，保留4位小数。
样例输入
2 3
样例输出
0.7500
数据规模和约定
1≤n，m≤20
#一共有n类别，一共买了m张
#一共有i种，一共买了j张
def Solution(n,m):
a=[]
for p in range(n):
a.append([0]*m)
for i in range(n):
for j in range(m):
if j>=0 and i==0:#只买了一张,要求集齐一种
a[i][j]=pow(1/n,j)
elif j<i:#购买的数量不到总的种数:
a[i][j]=0
else:
a[i][j]=a[i][j-1]*((i+1)/n)+a[i-1][j-1]*(n-i)/n
print('{:.4f}'.format(a[n-1][m-1]))
n,m=map(int,input().split())
Solution(n,m)
3.拿金币——DP
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
有一个N x N的方格,每一个格子都有一些金币,只要站在格子里就能拿到里面的金币。你站在最左上角的格子里,每次可以从一个格子走到它右边或下边的格子里。请问如何走才能拿到最多的金币。
输入格式
第一行输入一个正整数n。
以下n行描述该方格。金币数保证是不超过1000的正整数。输出格式
最多能拿金币数量。
样例输入
3
1 3 3
2 2 2
3 1 2样例输出
11
数据规模和约定
n<=1000
def Solution(n, money, sum):
for i in range(n):
for j in range(n):
if i == 0 and j==0:
sum[i][j] = money[i][j]
elif i==0:
sum[i][j] = sum[i ][j- 1] + money[i][j]
elif j == 0:
sum[i][j] = sum[i - 1][j] + money[i][j]
else:
sum[i][j] = max(sum[i][j - 1], sum[i - 1][j]) + money[i][j]
return sum[n - 1][n - 1]
n = int(input())
money = list()
sum = list()
for i in range(n):
# money.append(list(map(int,input().split())))
money.append([int(i) for i in input().split()])
sum.append([0] * n)
print(Solution(n,money,sum))
4.Sine之舞
题目描述
最近FJ为他的奶牛们开设了数学分析课，FJ知道若要学好这门课，必须有一个好的三角函数基本功。所以他准备和奶牛们做一个“Sine之舞”的游戏，寓教于乐，提高奶牛们的计算能力。
不妨设
An=sin(1–sin(2+sin(3–sin(4+...sin(n))...)
Sn=(...(A1+n)A2+n-1)A3+...+2)An+1
FJ想让奶牛们计算Sn的值，请你帮助FJ打印出Sn的完整表达式，以方便奶牛们做题。输入格式
仅有一个数：N<201。
输出格式
请输出相应的表达式Sn，以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入
复制
3样例输出
复制
((sin(1)+3)sin(1-sin(2))+2)sin(1-sin(2+sin(3)))+1
n = int(input())
def An_print(n):
An = ''
for i in range(1, n + 1):
if i % 2 == 1:
An += 'sin(%d-' % i
else:
An += 'sin(%d+' % i
if i == n:
An = An[:-1]
An += ')' * n
return An
def Sn_print(n):
Sn = ''
Sn += '(' * (n - 1)
for i in range(1, n + 1):
Sn += An_print(i)
Sn += '+%d)' % (n - i + 1)
Sn = Sn[:-1]
return Sn
print(Sn_print(n))
5.完美的代价
题目描述
回文串，是一种特殊的字符串，它从左往右读和从右往左读是一样的。小龙龙认为回文串才是完美的。现在给你一个串，它不一定是回文的，请你计算最少的交换次数使得该串变成一个完美的回文串。
交换的定义是：交换两个相邻的字符
例如mamad
第一次交换 ad : mamda
第二次交换 md : madma
第三次交换 ma : madam (回文！完美！)输入格式
第一行是一个整数N，表示接下来的字符串的长度(N < = 8000)
第二行是一个字符串，长度为N.只包含小写字母输出格式
如果可能，输出最少的交换次数。
否则输出Impossible样例输入
复制
5 mamad样例输出
复制
3
6.礼物
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
JiaoShou在爱琳大陆的旅行完毕，即将回家，为了纪念这次旅行，他决定带回一些礼物给好朋友。
在走出了怪物森林以后，JiaoShou看到了排成一排的N个石子。
这些石子很漂亮，JiaoShou决定以此为礼物。
但是这N个石子被施加了一种特殊的魔法。
如果要取走石子，必须按照以下的规则去取。
每次必须取连续的2*K个石子，并且满足前K个石子的重量和小于等于S，后K个石子的重量和小于等于S。
由于时间紧迫，Jiaoshou只能取一次。
现在JiaoShou找到了聪明的你，问他最多可以带走多少个石子。输入格式
第一行两个整数N、S。
第二行N个整数，用空格隔开，表示每个石子的重量。输出格式
第一行输出一个数表示JiaoShou最多能取走多少个石子。
样列输入
8 3
1 1 1 1 1 1 1 1样列输出
6
样列解释
任意选择连续的6个1即可。
数据规模和约定
对于20%的数据：N<=1000
对于70%的数据：N<=100,000
对于100%的数据：N<=1000,000，S<=10^12，每个石子的重量小于等于10^9，且非负
day4
1.铺地板——DFS
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
有一条长度为n的过道，很窄，只有一个地板砖宽。地板砖有两个规格，一种长度为1，一种长度为2。数量无限多。现在想知道一共有多少种地板铺法。比如当n＝3时，共有三种铺法：1 1 1；1 2；2 1；
输入格式
一个整数n，表示过道的长度n
输出格式
一个整数，表示铺地板的方案数
样例输入
3
样例输出
3
数据规模和约定
n小于32
def Solution(n):
way=0
if n==2:
return 2
elif n==1:
return 1
else:
way=Solution(n-1)+Solution(n-2)
return way
n=int(input())
print(Solution(n))
#利用递归算法进行求解
day5
1.数字游戏——DFS
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。
例如:
3 1 2 4
4 3 6
7 9
16
现在如果知道N和最后得到的数字sum，请求出最初序列a[i]，为1～N的一个排列。若有多种答案，则输出字典序最小的那一个。数据保证有解。输入格式
第1行为两个正整数n，sum
输出格式
一个1～N的一个排列
样例输入
4 16
样例输出
3 1 2 4
数据规模和约定
0<n<=10
#60分，后面回来填坑
import itertools
def Solution(n, sum):
a = []
c = []
for i in range(1, n + 1):
a.append(i)
a = list(itertools.permutations(a))
for i in a:
c.append(list(i))
for j in range(n):
for i in c:
for p in range(n - j - 1):
i[p] = i[p] + i[p + 1]
if j != n - 1:
i.pop(len(i) - 1)
m = 0
for i in c:
if sum == i[0]:
for j in a[m]:
print(j, end=' ')
break
m += 1
n, sum = map(int, input().split())
Solution(n, sum)
#90分，后面回来填坑
n,sum=map(int,input().split())
vis=[0]*(n+1)
num=[0]*(n+1)
global flag
flag=0
def dfs(step):
global flag
if flag==0:
if step==n+1:
c=[]
c.extend(num)
for i in range(n-1):
for j in range(1, n - i):
c[j] = c[j] + c[j + 1]
a = c[1]
if a==sum:
flag=1
for i in num[1:]:
print(i,end=' ')
return
if flag==0:
for i in range(1,n+1):
if vis[i]==0:
num[step]=i
vis[i]=1
dfs(step+1)
vis[i]=0
dfs(1)day6
1.无聊的逗——DP
资源限制
内存限制：256.0MB C/C++时间限制：1.0s Java时间限制：3.0s Python时间限制：5.0s
问题描述
逗志芃在干了很多事情后终于闲下来了，然后就陷入了深深的无聊中。不过他想到了一个游戏来使他更无聊。他拿出n个木棍，然后选出其中一些粘成一根长的，然后再选一些粘成另一个长的，他想知道在两根一样长的情况下长度最长是多少。
输入格式
第一行一个数n，表示n个棍子。第二行n个数，每个数表示一根棍子的长度。
输出格式
一个数，最大的长度。
样例输入
4
1 2 3 1样例输出
3
数据规模和约定
n<=15
#吐血80分，后面回来填坑
def odd_test(a):
if sum(a) % 2 == 0:
return True
else:
if len(a):
del a[0]
odd_test(a)
else:
return
def Solution(a):
a.sort()
plus = sum(a)
while len(a):
if odd_test(a):
W = int(plus / 2)
N = len(a)
wt = [0]
wt.extend(a)
val = [0]
val.extend(a)
dp = []
for i in range(N + 1):
dp.append([0] * (W + 1))
for i in range(N + 1):
for w in range(W + 1):
if i == 0 or w == 0:
dp[i][w] = 0
elif w - wt[i] < 0:
dp[i][w] = dp[i - 1][w]
else:
dp[i][w] = max(dp[i - 1][w], dp[i - 1][w - wt[i]] + val[i])
if dp[i][w] == W:
print(W)
break
else:
del a[0]
return
n = int(input())
a=list(map(int,input().split()))
Solution(a)
415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
