2024年春季学期《算法分析与设计》练习9

最新推荐文章于 2024-09-18 20:33:32 发布

没啥实力

最新推荐文章于 2024-09-18 20:33:32 发布

阅读量1.2k

点赞数 8

文章标签：算法

本文链接：https://blog.csdn.net/weixin_74021012/article/details/138171271

版权

问题 A: 斜线最大最小值

[命题人 : 201501010119]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 986 提交量: 2239 统计

题目描述

求如图所示一个上三角矩阵中每一条斜线中的最大元素(L)和最小元素(S)。

输入

每组输入包括两部分，一部分为数字n，表示三角矩阵的行数。
第二部分即为三角矩阵。

输出

每一个对角线输出一行，每行包括Lx=Max, Sx=Min，其中x为斜线序号（序号从1开始），Max为该斜线上的最大值，Min为该斜线上的最小值。

样例输入 Copy

6
1 3 5 7 11 20
0 6 8 2 3 13
0 0 7 4 8 9
0 0 0 18 3 10
0 0 0 0 12 6
0 0 0 0 0 15

样例输出 Copy

L1=18, S1=1
L2=8, S2=3
L3=10, S3=2
L4=9, S4=3
L5=13, S5=11
L6=20, S6=20

while True:
    n = int(input())
    arr = []
    for i in range(n):
        arr.append(list(map(int, input().split())))
    for r in range(n):
        exp = []
        for i in range(n):
            j = i + r
            if j < n:
                exp.append(arr[i][j])
        print('L' + str(r + 1) + '=' + str(max(exp)) + ', ' + 'S' + str(r + 1) + '=' + str(min(exp)))

问题 B: 矩阵连乘问题-备忘录法求最优值

[命题人 : admin]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 718 提交量: 1476 统计

题目描述

使用备忘录法求解矩阵连乘问题，输出最少乘法次数。

输入

每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。

输出

矩阵连乘最优计算次数。

样例输入 Copy

7
30 35 15 5 10 20 25

样例输出 Copy

def bwl(arr, i, j):
    if dp[i][j] > 0:
        return dp[i][j]
    if i == j:
        return 0
    u = bwl(arr, i + 1, j) + arr[i - 1] * arr[i] * arr[j]
    for k in range(i + 1, j):
        t = bwl(arr, i, k) + bwl(arr, k + 1, j) + arr[i - 1] * arr[k] * arr[j]
        if u > t:
            u = t
    dp[i][j] = u
    return u
 
while True:
    n = int(input())
    arr = list(map(int, input().split()))
    dp = [[0] * n for _ in range(n + 1)]
    for r in range(2, n + 1):
        for i in range(1, n + 1 - r):
            j = i + r - 1
            bwl(arr, i, j)
    print(dp[1][-1])

问题 C: 矩阵连乘问题-动态规划求最优值

[命题人 : 201501010119]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 1123 提交量: 1847 统计

题目描述

使用动态规划算法求解矩阵连乘问题，输出最少乘法次数。

输入

每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。

输出

矩阵连乘最优计算次数。

样例输入 Copy

7
30 35 15 5 10 20 25

样例输出 Copy

while True:
    n = int(input())
    arr = list(map(int, input().split()))
    dp = [[0] * n for _ in range(n + 1)]
    for r in range(2, n + 1):
        for i in range(1, n + 1 - r):
            j = i + r - 1
            dp[i][j] = dp[i + 1][j] + arr[i - 1] * arr[i] * arr[j]
            for k in range(i + 1, j):
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + arr[i - 1] * arr[k] * arr[j])
    print(dp[1][-1])

问题 D: 矩阵连乘问题-构造最优解

[命题人 : 201501010119]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 1050 提交量: 1841 统计

题目描述

使用动态规划算法求解矩阵连乘问题。

输入

每组数据包括两行，第一行为数组长度n，第二行为存储矩阵维数的一维数组。

输出

矩阵连乘最优计算次序。

样例输入 Copy

7
30 35 15 5 10 20 25

样例输出 Copy

A[2:2] * A[3:3]
A[1:1] * A[2:3]
A[4:4] * A[5:5]
A[4:5] * A[6:6]
A[1:3] * A[4:6]

def traceback(ind, i, j):
    if i == j:
        return
    traceback(ind, i, ind[i][j])
    traceback(ind, ind[i][j] + 1, j)
    res.append('A[' + str(i) + ':' + str(ind[i][j]) + ']' + ' * ' + 'A[' + str(ind[i][j] + 1) + ':' + str(j) + ']')
 
 
while True:
    n = int(input())
    res = []
    arr = list(map(int, input().split()))
    dp = [[0] * n for _ in range(n + 1)]
    ind = [[0] * n for _ in range(n + 1)]
    for r in range(2, n + 1):
        for i in range(1, n + 1 - r):
            j = i + r - 1
            dp[i][j] = dp[i + 1][j] + arr[i - 1] * arr[i] * arr[j]
            ind[i][j] = i
            for k in range(i + 1, j):
                t = dp[i][k] + dp[k + 1][j] + arr[i - 1] * arr[k] * arr[j]
                if t < dp[i][j]:
                    dp[i][j] = t
                    ind[i][j] = k
    traceback(ind, 1, n-1)
    for i in range(len(res)):
        print(res[i])

问题 E: 石子合并问题

[命题人 : 201501010119]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 972 提交量: 2355 统计

题目描述

在一条直线上有n堆石子，每堆有一定的数量，每次可以将两堆相邻的石子合并，合并后放在两堆的中间位置，合并的费用为两堆石子的总数。求把所有石子合并成一堆的最小花费。例如：输入{1，2，3，4，5}，输出33。【3+6+9+15=33】

输入

本题应该处理到文件尾，每组输入包括两行，第一行为石子堆的个数n，第二行则为每堆石子的个数。

输出

输出最小花费。

样例输入 Copy

5
1 2 3 4 5

样例输出 Copy

import math
 
while True:
    n = int(input())
    arr = list(map(int, input().split()))
    dp = [[0] * (n + 1) for _ in range(n + 1)]
    exp = [[0] * (n + 1) for _ in range(n + 1)]
    for i in range(1, n + 1):
        exp[i][i] = arr[i - 1]
    for i in range(1, n):
        for j in range(i + 1, n + 1):
            exp[i][j] = exp[i][j - 1] + arr[j - 1]
    for r in range(2, n + 1):
        for i in range(1, n + 2 - r):
            j = i + r - 1
            dp[i][j] = math.inf
            for k in range(i, j):
                dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j])
            dp[i][j] += exp[i][j]
    print(dp[1][-1])

每次遍历斜线时将值设置为充分大（math库的inf）然后在比较去最小

问题 F: X星人的基因

[命题人 : admin]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 679 提交量: 2092 统计

题目描述

X星人的基因由A、B、C、D、E五种不同的结构组合而成。
如果两个性别不同的X星人的基因序列相似度大于50%，按照X星的法律他们是禁止结婚的，等于50%据说还是可以的。
那么基因的相似度怎么计算呢？分别从两个人身上取长度均为N的基因片段，如果它们的最长公共子序列为M，则相似度=M/N。是不是很简单呢？
现在给你两段X星人的基因序列片段，请你判断他们是不是可以结婚？

输入

每一组测试数据包含3行，
第1行数字N表示待比较基因序列片段的长度，N<=10^3。
第2行和第3行为两个长度为N的基因序列片段。
输入0表示结束。

输出

两个X星人是否可以结婚，如果可以输出”Yes“，如果不可以输出”No“。

样例输入 Copy

8
A B C D E A B C
A C C D C B A E
6
A B C D E E
A E D C B B
0

样例输出 Copy

Yes
Yes

def longest(s1, s2):
    m = len(s1)
    n = len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
 
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1] + 1
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
 
    return dp[m][n]
 
 
while True:
    n = int(input())
    if n == 0:
        break
    s1 = ''.join(list(map(str, input().split())))
    s2 = ''.join(list(map(str, input().split())))
    res = longest(s1, s2)
    if res > n * (1 / 2):
        print('No')
    else:
        print('Yes')

最长公共子序列问题

问题 G: 路径统计

[命题人 : admin]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 63 提交量: 359 统计

题目描述

小Z住在一个建筑物很整齐的矩形小区的左下角，学校在小区右上角。
小Z和学校之间有M条东西向的道路，有N条南北向的道路。小Z的爸爸每天早上开车送他上学，但是这些道路都是单行线，只能朝北走或者朝东走。
由于道路施工，在某个路口现在有一个警示桩，表示此处暂不能通行。
现在告诉你M和N的值，以及警示桩的位置，请你统计从小Z家到学校有多少条不同的路径（答案对1e9+7取模）？
下图是当M=4，N=4，在从左到右第2条南北方向的道路和从上至下第2条东西方向的道路的交叉口有一个警示桩的示意图。

输入

单组输入。
第1行输入两个正整数M和N，分别表示东西向道路和南北向道路的数量，M和N均不超过100，两者之间用英文空格隔开。
第2行输入两个正整数X和Y，表示警示桩的位置，X表示从左到右第X条南北方向的道路，Y表示从上至下第Y条东西方向的道路。（1<=X<=N，1<=Y<=M）

输出

输出从小Z家到学校的不同路径条数（答案对1e9+7取模）。

样例输入 Copy

4 4
2 2

样例输出 Copy

while True:
    MOD = int(1e9 + 7)
    m, n = map(int, input().split())
    x, y = map(int, input().split())
    dp = [[0] * n for _ in range(m)]
    arr = [[0] * n for _ in range(m)]
    arr[x - 1][y - 1] = 1
    for i in range(m - 1, -1, -1):
        if arr[i][0] == 1:
            break
        dp[i][0] = 1
    for i in range(n):
        if arr[-1][i] == 1:
            break
        dp[-1][i] = 1
    for i in range(m - 2, -1, -1):
        for j in range(1, n):
            if arr[i][j] == 1:
                continue
            dp[i][j] = (dp[i + 1][j] % MOD + dp[i][j - 1] % MOD) % MOD
    print(dp[0][-1] % MOD)

不知道少了什么条件（18%）

问题 H: 删数问题

[命题人 : admin]

时间限制 : 1.000 sec 内存限制 : 128 MB

提交问题列表

解决: 42 提交量: 123 统计

题目描述

在一个数列中有N个正整数，现在需要对这个数列进行若干趟删数操作。
每趟删数操作的规则和要求说明如下：
(1) 一趟删数操作包含1次或多次删除操作，每次删除操作均需要删除一个数。
(2) 下一个要删除的数的下标必须大于上一个删除的数。
(3) 下一个要删除的数的值不能大于上一个删除的数。
通过M趟删数操作后正好将数列中所有数字全部都删除完毕。
请问M的最小值为多少？即最少需要多少趟删数操作才可以将数列清空？

输入

单组输入。
第1行输入一个正整数N，表示数列中数字的总个数。（N<=10^3）
第2行输入N个正整数，两两之间用空格隔开。

输出

输出M的最小值，即最少需要多少趟删数操作才能将数列清空。

样例输入 Copy

8
1 5 5 4 3 4 6 2

样例输出 Copy

import bisect
 
while True:
    n = int(input())
    exp = list(map(int, input().split()))
    arr = []
    k = 0
    for i in range(n):
        x = exp[i]
        if k == 0 or x > arr[-1]:
            arr.append(x)
            k += 1
        else:
            ind = bisect.bisect_left(arr, x)
            if ind < k:
                arr[ind] = x
            else:
                arr.append(x)
                k += 1
    print(k)

最长递减子序列问题