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

问题 A: 1的个数

题目描述

输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

输入

 输入一个整数（int类型）。

输出

这个数转换成2进制后，输出1的个数。

样例输入 Copy

5

样例输出 Copy

2

i = int(input())
bs = bin(i)
ans = 0
for b in bs :
    if b == '1':
       ans += 1
print(ans)

问题 B: 又一道简单题

题目描述

输入一个四个数字组成的整数 n，你的任务是数一数有多少种方法，恰好修改一个数字，把它 变成一个完全平方数（不能把首位修改成 0）。比如 n=7844，有两种方法：3844=622 和 7744=882。 

输入

输入第一行为整数 T (1<=T<=1000)，即测试数据的组数，以后每行包含一个整数 n (1000<=n<=9999)。 

输出

对于每组数据，输出恰好修改一个数字，把 n变成完全平方数的方案数

样例输入 Copy

2
7844
9121

样例输出 Copy

Case 1: 2
Case 2: 0

import math

def pf(n):
    root = math.sqrt(n)
    return int(root + 0.5) ** 2 == n

def fa(n):
    count = 0
    for i in range(4):  # 对每一位进行遍历
        temp = list(str(n).zfill(4))
        if i == 0:
            for j in range(1,10):
                temp[i] = str(j)
                if pf(int(''.join(temp))) and(int(''.join(temp))) != n :
                    count += 1
        else:
            for j in range(10):  
                temp[i] = str(j)
                if pf(int(''.join(temp))) and (int(''.join(temp))) != n:
                    count += 1
    return count

while 1:
    n = int(input())
    aa = []
    ans = 0
    for i in range(n):
        num = int(input())
        aa.append(num)
    for i in range (len(aa)):
        print(f'Case {i + 1}: {fa(aa[i])}')

问题 C: 安置路灯

题目描述

小Q正在给一条长度为n的道路设计路灯安置方案。

为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。

小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。

小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。

输入

输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数
接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。
第二行一个字符串s表示道路的构造,只包含'.'和'X'。

输出

对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。

样例输入 Copy

2
3
.X.
11
...XX....XX

样例输出 Copy

1
3

t = int(input())
for i in range(t):
    n = int(input())
    s = input()
    i = 0
    ans = 0
    while i < n:
        if s[i] == 'X':
            i += 1
        else:
            ans += 1
            i += 3
    print(ans)

问题 D: 单源最短路径问题

题目描述

编程实现Dijkstra算法，求一个有向加权图中，从源点出发到其他各个顶点的最短路径。

输入

第1行第1个值表示顶点个数，第2个值表示边个数；第2行开始为边（两个顶点，边的起点和终点）及权重。

输出

顶点0到每一个顶点的最短路径长度。

样例输入 Copy

5 7
0 1 10
0 3 30
0 4 100
1 2 50
2 4 10
3 2 20
3 4 60

样例输出 Copy

0 10 50 30 60

import heapq

def dijkstra(graph, start):

    diss = {v: float('infinity') for v in graph}
    diss[start] = 0

    priority_queue = [(0, start)]

    while priority_queue:

        current_dis, current_v = heapq.heappop(priority_queue)

        if current_dis > diss[current_v]:
            continue

        for neighbor, weight in graph[current_v].items():
            dis = current_dis + weight

            if dis < diss[neighbor]:
                diss[neighbor] = dis
                heapq.heappush(priority_queue, (dis, neighbor))

    return diss

dot,line = map(int,input().split())
graph = {i: {} for i in range(dot)}

for _ in range(line):
    start, end, weight = map(int, input().split())
    graph[start][end] = weight

start_v = 0
shortest_paths = dijkstra(graph, start_v)

print(' '.join(map(str, [shortest_paths[i] for i in range(dot)])))

问题 E: ABC + DEF = GHI

题目描述

用1, 2, 3...9 这九个数字组成一个数学公式，满足：ABC + DEF = GHI，每个数字只能出现一次，编写程序输出所有的组合。

输入

无

输出

输出所有的 ABC + DEF = GHI，
每行一条数据，格式为ABC+DEF=GHI
输出结果按照ABC升序排列，如果ABC相同，则按照DEF升序排列。

from itertools import permutations

# 生成1-9的所有排列
digits = list(range(1, 10))
all_permutations = permutations(digits)

# 存储满足条件的组合
valid_combinations = []

# 检查每个排列
for perm in all_permutations:
    ABC = perm[0] * 100 + perm[1] * 10 + perm[2]
    DEF = perm[3] * 100 + perm[4] * 10 + perm[5]
    GHI = perm[6] * 100 + perm[7] * 10 + perm[8]

    if ABC + DEF == GHI:
        valid_combinations.append((ABC, DEF, GHI))

# 按照要求排序
valid_combinations.sort()

# 输出结果
for ABC, DEF, GHI in valid_combinations:
    print(f"{ABC}+{DEF}={GHI}")

问题 F: 油田问题

题目描述

输入一个m行n列的字符矩阵，统计字符“@”组成多少个八连块。如果两个字符“@”所在的格子相邻（横、竖或者对角线方向），即属于同一个八连块。

输入

多组输入
输入行数m，以及列数n。
然后输入*和@
1<=n,m<=100

输出

联通块个数

样例输入 Copy

5 5
****@
*@@*@
*@**@
@@@*@
@@**@

样例输出 Copy

2

def dfs(w: int, e: int):
    q = [[w, e]]
    while q:
        tw, te = q.pop(0)
        for d in directions:
            dw, de = tw + d[0], te + d[1]
            if 0 <= dw < m and 0 <= de < n and maze[dw][de] == '@' and visited[dw][de] == 0:
                visited[dw][de], _ = cnt, q.insert(0, [dw, de])
    return


directions = [[-1, 0], [1, 0], [0, -1], [0, 1], [-1, -1], [1, -1], [-1, 1], [1, 1]]
while True:
    try:
        m, n = map(int, input().split())
        maze, visited, cnt = [input().strip() for _ in range(m)], [[0] * n for _ in range(m)], 0
        for i in range(m):
            for j in range(n):
                if maze[i][j] == '@' and visited[i][j] == 0:
                    visited[i][j], cnt = cnt + 1, cnt + 1
                    dfs(i, j)
        # print(visited)
        print(cnt)
    except:
        break