蓝桥三十一天刷题（python组）||第三天

门牌制作

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝要为一条街的住户制作门牌号。

这条街一共有 20202020 位住户，门牌号从 11 到 20202020 编号。

小蓝制作门牌的方法是先制作 00 到 99 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、71、0、1、7，即需要 11 个字符 00，22 个字符 11，11 个字符 77。

请问要制作所有的 11 到 20202020 号门牌，总共需要多少个字符 22？

求解

cnt_2=0
for i in range(1,2021):
    cnt_2+=sum(1 if j=='2' else 0 for j in str(i))
print(cnt_2)

货物摆放

题目描述

小蓝有一个超大的仓库，可以摆放很多货物。

现在，小蓝有 n 箱货物要摆放在仓库，每箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都必须严格平行于长、宽、高。

小蓝希望所有的货物最终摆成一个大的长方体。即在长、宽、高的方向上分别堆 L、�W、H 的货物,满足 n=L×W×H。

给定 n，请问有多少种堆放货物的方案满足要求。

例如，当 n=4 时，有以下 66 种方案：1×1×4、1×2×2、1×4×1、2×1×2、2×2×1、4×1×11×1×4、1×2×2、1×4×1、2×1×2、2×2×1、4×1×1。

请问，当 n=2021041820210418 （注意有 16 位数字）时，总共有多少种方案？

提示：建议使用计算机编程解决问题。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

求解

n=2021041820210418
a=[]
for i in range(1,int(pow(n,0.5))+1):
    if n%i==0:
        a.append(i)
        if n/i!=i:
            a.append(n/i)
cnt=0
for i in a:
    for j in a:
        for k in a:
            if i*j*k==n:
                cnt+=1
print(a)

跳跃

题目描述

小蓝在一个 n 行 m 列的方格图中玩一个游戏。

开始时，小蓝站在方格图的左上角，即第 11 行第 11 列。

小蓝可以在方格图上走动，走动时，如果当前在第 r 行第 c 列，他不能走到行号比 r 小的行，也不能走到列号比 c 小的列。同时，他一步走的直线距离不超过 33。

例如，如果当前小蓝在第 33 行第 55 列，他下一步可以走到第 33 行第 66 列、第 33 行第 77 列、第 33 行第 88 列、第 44 行第 55 列、第 44 行第 66 列、第 44 行第 77 列、第 55 行第 55 列、第 55 行第 66 列、第 66 行第 55 列之一。

小蓝最终要走到第 n 行第 m 列。

在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。

小蓝希望，从第 11 行第 11 列走到第 n 行第 m 列后，总的权值和最大。请问最大是多少？

输入描述

输入的第一行包含两个整数 n,m，表示图的大小。

接下来 n 行，每行 m 个整数，表示方格图中每个点的权值。

其中，1≤n≤100，−104≤权值≤104。

输出描述

输出一个整数，表示最大权值和。

输入输出样例

示例 1

输入

3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

输出

15

求解

本人代码

设dp[i][j]为i行j列（以0开始）时的最大收益。

dp[i][j]=a[i][j]+max(dp[i-3][j],dp[i-2][j],\

dp[i-2][j-1],dp[i-1][j],\

dp[i-1][j-1],dp[i-1][j-2],\

dp[i][j-1],dp[i][j-2],\

dp[i][j-3])

需要输出dp[m][n]。

n,m=map(int,input().split())
a=[[0]*m]*n
dp=[[0]*m]*n
for i in range(n):
    a[i]=list(map(int,input().split()))
dp[0][0]=a[0][0]
for i in range(n):
    for j in range(m):
        if i-3>=0:
            if j-3>=0:
                dp[i][j]=a[i][j]+max(dp[i-3][j],dp[i-2][j],\
                                     dp[i-2][j-1],dp[i-1][j],\
                                     dp[i-1][j-1],dp[i-1][j-2],\
                                     dp[i][j-1],dp[i][j-2],\
                                     dp[i][j-3])
            elif j-2==0:
                dp[i][j]=a[i][j]+max(dp[i-3][j],dp[i-2][j],\
                                     dp[i-2][j-1],dp[i-1][j],\
                                     dp[i-1][j-1],dp[i-1][j-2],\
                                     dp[i][j-1],dp[i][j-2])
            elif j-1==0:
                dp[i][j]=a[i][j]+max(dp[i-3][j],dp[i-2][j],\
                                     dp[i-2][j-1],dp[i-1][j],\
                                     dp[i-1][j-1],dp[i][j-1])
            elif j==0:
                dp[i][j]=a[i][j]+max(dp[i-3][j],dp[i-2][j],dp[i-1][j])
        elif i-2==0:
            if j-3>=0:
                dp[i][j]=a[i][j]+max(dp[i-2][j],\
                                     dp[i-2][j-1],dp[i-1][j],\
                                     dp[i-1][j-1],dp[i-1][j-2],\
                                     dp[i][j-1],dp[i][j-2],\
                                     dp[i][j-3])
            elif j-2==0:
                dp[i][j]=a[i][j]+max(dp[i-2][j],\
                                     dp[i-2][j-1],dp[i-1][j],\
                                     dp[i-1][j-1],dp[i-1][j-2],\
                                     dp[i][j-1],dp[i][j-2])
            elif j-1==0:
                dp[i][j]=a[i][j]+max(dp[i-2][j],\
                                     dp[i-2][j-1],dp[i-1][j],\
                                     dp[i-1][j-1],dp[i][j-1])
            elif j==0:
                dp[i][j]=a[i][j]+max(dp[i-2][j],dp[i-1][j])
        elif i-1==0:
            if j-3>=0:
                dp[i][j]=a[i][j]+max(dp[i-1][j],\
                                        dp[i-1][j-1],dp[i-1][j-2],\
                                        dp[i][j-1],dp[i][j-2],\
                                        dp[i][j-3])
            elif j-2==0:
                dp[i][j]=a[i][j]+max(dp[i-1][j],\
                                        dp[i-1][j-1],dp[i-1][j-2],\
                                        dp[i][j-1],dp[i][j-2])
            elif j-1==0:
                dp[i][j]=a[i][j]+max(dp[i-1][j],\
                                        dp[i-1][j-1],dp[i][j-1])
            elif j==0:
                dp[i][j]=a[i][j]+dp[i-1][j]
        elif i==0:
            if j-3>=0:
                dp[i][j]=a[i][j]+max(dp[i][j-1],dp[i][j-2],\
                                        dp[i][j-3])
            elif j-2==0:
                dp[i][j]=a[i][j]+max(dp[i][j-1],dp[i][j-2])
            elif j-1==0:
                dp[i][j]=a[i][j]+dp[i][j-1]
            elif j==0:
                continue
print(dp[n-1][m-1])

lanqiao8589052951的代码

这位佬的方法是，因为起点和终点都必须要经过，所以把终点当成起点处理。

n,m=map(int,input().split())
arr=[]
for i in range(n):
    arr.append(list(map(int,input().split())))
L=[[-10001]*(m+3) for i in range(n+3)]
for i in range(n-1,-1,-1):
    for j in range(m-1,-1,-1):
        if i==n-1 and j==m-1:
            L[i][j]=arr[i][j]
        else:
            L[i][j]=arr[i][j]+max(L[i][j+1],L[i][j+2],L[i][j+3],L[i+1][j],L[i+1][j+1],L[i+1][j+2],L[i+2][j],L[i+2][j+1],L[i+3][j])
print(L[0][0])

重新排序

问题描述

给定一个数组 A 和一些查询Li,Ri, 求数组中第 Li 至第 Ri 个元素之和。

小蓝觉得这个问题很无聊, 于是他想重新排列一下数组, 使得最终每个查 询结果的和尽可能地大。小蓝想知道相比原数组, 所有查询结果的总和最多可 以增加多少?

输入格式

输入第一行包含一个整数 n 。

第二行包含 n 个整数A1,A2,⋯,An, 相邻两个整数之间用一个空格分隔。

第三行包含一个整数 m 表示查询的数目。

接下来 m 行, 每行包含两个整数 Li、Ri, 相邻两个整数之间用一个空格分 隔。

输出格式

输出一行包含一个整数表示答案。

样例输入

5
1 2 3 4 5
2
1 3
2 5

样例输出

4

样例说明

原来的和为 6+14=206+14=20, 重新排列为 (1,4,5,2,3)(1,4,5,2,3) 后和为 10+14=2410+14=24, 增 加了 4。

评测用例规模与约定

对于 30%30% 的评测用例，n,m≤50;

对于 50%50% 的评测用例, n,m≤500;

对于 70%70% 的评测用例, n,m≤5000;

对于所有评测用例, 1≤n,m≤105,1≤Ai≤106,1≤Li≤Ri≤106 。

求解

out-of-range，记录一下思路。

对于一个数字序列，记它的一些切片的头和尾分别为h1,,h2,...和t1,t2...，组成序列H和T。如果要求所有切片的和，可发现把H、T从小到大排序后，其中元素按下标两两组成的序列对应的切片的元素总和，与原序列给定切片元素总和大小相等。示意图如下：

对于等效的切片，重叠的部分越多，那个部分就填入原数字序列中越大的元素，以此规则生成新数字序列。

n=int(input())
a=list(map(int,input().split()))
m=int(input())
L_R=[]
sort_H=[]
sort_T=[]
for i in range(m):
    L_R.append(list(map(int,input().split())))
    sort_H.append(L_R[i][0])
    sort_T.append(L_R[i][1])
sort_H.sort(reverse=True)
sort_T.sort()

qujian_len=[]
sort_a=sorted(a,reverse=True)
new_a=[0]*n

for i in range(m):
    if i==0:
        new_a[sort_H[i]-1:sort_T[i]]=sort_a[:sort_T[i]-sort_H[i]+1]
        del sort_a[:sort_T[i]-sort_H[i]+1]
    else:
        j=sort_H[i]-1
        k=0
        while(j<sort_H[i-1]-1):
            new_a[j]=sort_a[k]
            j+=1
            k+=1
        del sort_a[:sort_H[i-1]-sort_H[i]]

        j=sort_T[i-1]
        k=0
        while(j<sort_T[i]):
            new_a[j]=sort_a[k]
            j+=1
            k+=1
        del sort_a[:sort_T[i]-sort_T[i-1]]

old=0
new=0
for i in range(m):
    old+=sum(a[L_R[i][0]-1:L_R[i][1]])
    new+=sum(new_a[L_R[i][0]-1:L_R[i][1]])

print(new-old)