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

问题 A: X星数列

题目描述

爱冒险的X星人在一艘海底沉船上发现了一串神秘数列，这个数列的前8项如下：
5, 8, 18, 34, 70, 138, 278, 554
X星人对这串数列产生了浓厚的兴趣，他希望你能够帮他发现这个神秘数列中所蕴含的规律，并且编写一个程序输出该数列前N项的和。
当输入一个正整数N时，请输出这个神秘数列前N项的和。

输入

单组输入，每组输入一个正整数N（N<=20）。

输出

输出一个正整数，对应这个数列前N项的和。

样例输入 Copy

4

样例输出 Copy

65

def sum_of_hanshu_dp(n):
    if n == 1:
        return 5
    elif n == 2:
        return 8 + 5
    # 初始化动态规划数组，并设置前两项的值  
    dp = [None] * (n + 1)  
    dp[1] = 5  
    dp[2] = 8
      
    # 计算剩余项的值并累加求和  
    total_sum = dp[1] + dp[2]  
    for i in range(3, n + 1):  
        dp[i] = 2 * dp[i - 2] + dp[i - 1]  
        total_sum += dp[i]  
      
    return total_sum  

n = int(input())  
print(sum_of_hanshu_dp(n))

问题 B: X星计数

题目描述

热爱数学的X星人又发现了一个有趣的游戏，游戏名叫做：1的个数。
具体游戏规则为：给定一个十进制正整数，计算对应的二进制整数中有多少个1。

输入

多组输入。

第一行输入一个整数T（1<=T<=100)，表示总共有T组数据。

接下来T行，每行一个十进制正整数n，其中1<=n<=1e^9。

输出

对于每一组输入，输出十进制正整数对应的二进制整数中包含的1的个数。

样例输入 Copy

3
1
9
12

样例输出 Copy

1
2
2

#十进制转二进制    bin()
#十进制转八进制    oct()
#十进制转十六进制   hex()
#转十进制          int()


c = int(input())
while c > 0 :
    c -= 1
    n = int(input())
    b = bin(n)
    i = 0
    for x in b:
        if x == '1':
           i += 1
    print(i)

问题 C: 第k大元素

题目描述

输入一个整数数组，请求出该数组的第k大元素。要求时间复杂度为O(n)。
 

输入

每组输入包括两行，第一行为k值；第二行为一个整数数组，两个数字之间用空格隔开。数组中元素个数小于1000。

输出

输出第k大元素的值，每个结果占一行

样例输入 Copy

2 
3 2 1 5 6 4

样例输出 Copy

5

while 1:
    k = int(input())
    nums = list(map(int,input().split()))
    nums = sorted(nums)
    print(nums[len(nums)-k])

问题 D: 棋盘覆盖问题

题目描述

在一个n×n (n = 2k)个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。
在棋盘覆盖问题中，要用4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

 

输入

多组测试用例，每组测试用例包括两部分，
第一部分为方格的宽度n，
第二部分则为方格，特殊方格为-1，其他方格为0。
 

输出

输出覆盖后的方案

样例输入 Copy

4
-1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

样例输出 Copy

-1 2 4 4
2 2 1 4
3 1 1 5
3 3 5 5

def boardcheck(bh, bl, th, tl, size):
    if size == 1:
        return

    global title
    t = title + 1
    title = t
    s = size // 2

    if th < s + bh and tl < s + bl:
        boardcheck(bh, bl, th, tl, s)
    else:
        board[s + bh - 1][s + bl - 1] = t
        boardcheck(bh, bl, s + bh - 1, s + bl - 1, s)

    if th >= s + bh and tl < bl + s:
        boardcheck(bh + s, bl, th, tl, s)
    else:
        board[bh + s][bl + s - 1] = t
        boardcheck(bh + s, bl, bh + s, bl + s - 1, s)

    if th < s + bh and tl >= bl + s:
        boardcheck(bh, bl + s, th, tl, s)
    else:
        board[bh + s - 1][bl + s] = t
        boardcheck(bh, bl + s, bh + s - 1, bl + s, s)

    if th >= s + bh and tl >= s + bl:
        boardcheck(s + bh, s + bl, th, tl, s)
    else:
        board[s + bh][s + bl] = t
        boardcheck(s + bh, s + bl, s + bh, s + bl, s)


# 初始化全局变量


global board
global title

title = 0
board = []
# 读取棋盘大小
n = int(input().strip())
while n > 0:  # 假设输入正整数表示棋盘大小，0或负数表示结束
    board = [[0] * n for _ in range(n)]  # 创建指定大小的二维列表
    th, tl = -1, -1

    # 读取棋盘内容
    for i in range(n):
        row_input = input().strip().split()  # 分割每行的输入
        for j, num_str in enumerate(row_input):
            board[i][j] = int(num_str)  # 将字符串转换为整数
            if board[i][j] == -1:
                th, tl = i, j

                # 调用 boardcheck 函数
    boardcheck(0, 0, th, tl, n)

    # 打印更新后的棋盘
    for row in board:
        print(' '.join(map(str, row)))

        # 读取下一个棋盘的大小
    n = int(input().strip())
    title = 0  # 重置全局变量

问题 E: 大整数乘法

题目描述

使用分治算法实现两个大整数相乘。

输入

两个十进制大整数，满足每一个整数长度为2^n且两个大整数的长度相等。（多组数据）

输出

两个大整数的乘积。

样例输入 Copy

1234 5678

样例输出 Copy

7006652

#利用python的大内存
while 1:
    a,b = map(int,input().split(' '))
    print(a*b)

def karatsuba(x, y):
    # 基准情况: 如果x或y小于10，直接相乘返回结果
    if x < 10 and y < 10:
        return x * y

        # 获取x和y的长度
    n = max(len(str(x)), len(str(y)))
    # 确定分割点
    m = n // 2

    # 分割x和y为高位和低位
    a = x // 10 ** m
    b = x % 10 ** m
    c = y // 10 ** m
    d = y % 10 ** m

    # 递归计算三部分乘积
    ac = karatsuba(a, c)
    bd = karatsuba(b, d)
    ab_cd = karatsuba(a + b, c + d) - ac - bd

    # 合并结果
    product = ac * 10 ** (2 * m) + ab_cd * 10 ** m + bd
    return product


def multiply_large_numbers(x, y):
    # 转换为正数，并存储符号
    sign = -1 if (x < 0) ^ (y < 0) else 1
    x = abs(x)
    y = abs(y)

    # 计算乘积
    result = karatsuba(x, y)

    # 应用符号
    return sign * result

while 1:
    x,y = map(int,input().split(' '))
    print(multiply_large_numbers(x, y))

问题 F: 整数划分问题之备忘录法

题目描述

使用备忘录法编写一个程序，求一个正整数n的所有划分个数。 
例如，输入3，输出3；输入4，输出5。 

输入

多组输入，每一组是一个正整数n。

输出

输出划分数。

样例输入 Copy

3
4

样例输出 Copy

3
5

def dynamic_get_partition_count(n, max_num):  
    # 初始化二维列表，用于存储动态规划的状态  
    dp = [[0] * (max_num + 1) for _ in range(n + 1)]  
      
    for i in range(1, n + 1):  
        for j in range(1, min(i, max_num) + 1):  
            if j == 1 or i == 1:  
                dp[i][j] = 1  
            elif j == i:  
                dp[i][j] = dp[i][j - 1] + 1  
            elif i - j < j:  
                dp[i][j] = dp[i - j][i - j] + dp[i][j - 1]  
            else:  
                dp[i][j] = dp[i - j][j] + dp[i][j - 1]  
      
    # 返回整数n的划分个数，其中最大加数不超过n  
    return dp[n][max_num]  
  
# 主程序  
while True:   
    n = int(input())  
    # 调用函数计算并打印n的划分个数，其中最大加数不超过n  
    count = dynamic_get_partition_count(n, n)  
    print(count)